BZOJ5415[Noi2018]归程——kruskal重构树+倍增+堆优化dijkstra

题目描述

本题的故事发生在魔力之都，在这里我们将为你介绍一些必要的设定。魔力之都可以抽象成一个 n 个节点、m 条边的无向连通图（节点的编号从 1 至 n）。我们依次用 l,a 描述一条边的长度、海拔。作为季风气候的代表城市，魔力之都时常有雨水相伴，因此道路积水总是不可避免的。由于整个城市的排水系统连通，因此有积水的边一定是海拔相对最低的一些边。我们用水位线来描述降雨的程度，它的意义是：所有海拔不超过水位线的边都是有积水的。

Yazid 是一名来自魔力之都的OIer，刚参加完ION2018 的他将踏上归程，回到他温暖的家。 Yazid 的家恰好在魔力之都的 1 号节点。对于接下来 Q 天，每一天Yazid 都会告诉你他的出发点 v ，以及当天的水位线p。每一天，Yazid 在出发点都拥有一辆车。这辆车由于一些故障不能经过有积水的边。 Yazid 可以在任意节点下车，这样接下来他就可以步行经过有积水的边。但车会被留在他下车的节点并不会再被使用。需要特殊说明的是，第二天车会被重置，这意味着：

车会在新的出发点被准备好。
Yazid 不能利用之前在某处停放的车。 Yazid 非常讨厌在雨天步行，因此他希望在完成回家这一目标的同时，最小化他步行经过的边的总长度。请你帮助 Yazid 进行计算。本题的部分测试点将强制在线，具体细节请见【输入格式】和【子任务】。

输入输出格式

输入格式：

单个测试点中包含多组数据。输入的第一行为一个非负整数T，表示数据的组数。

接下来依次描述每组数据，对于每组数据：

第一行 2 个非负整数 n,m，分别表示节点数、边数。

接下来 mm 行，每行 4 个正整数u, v, l, a，描述一条连接节点 u, v 的、长度为 ll、海拔为 a 的边。在这里，我们保证1≤u,v≤n。

接下来一行 3 个非负数 Q, K, S ，其中 QQ 表示总天数，K∈0,1 是一个会在下面被用到的系数，S 表示的是可能的最高水位线。

接下来 Q 行依次描述每天的状况。每行 2 个整数 v_0; p_0 描述一天：
这一天的出发节点为v=(v0+K×lastans−1)modn+1。
这一天的水位线为p=(p0+K×lastans)mod(S+1)。
其中 lastans 表示上一天的答案（最小步行总路程）。特别地，我们规定第 1 天时 lastans = 0。在这里，我们保证1≤v0≤n,0≤p0≤S 。

对于输入中的每一行，如果该行包含多个数，则用单个空格将它们隔开。

输出格式：

依次输出各组数据的答案。对于每组数据：

输出 Q 行每行一个整数，依次表示每天的最小步行总路程。

输入输出样例

输入样例#1：

输出样例#1：

输入样例#2：

输出样例#2：

说明

【样例1 解释】第一天没有降水，Yazid 可以坐车直接回到家中。

第二天、第三天、第四天的积水情况相同，均为连接1; 2 号节点的边、连接3; 4 号点的边有积水。

对于第二天，Yazid 从2 号点出发坐车只能去往3 号节点，对回家没有帮助。因此 Yazid 只能纯靠徒步回家。

对于第三天，从4 号节点出发的唯一一条边是有积水的，车也就变得无用了。Yazid只能纯靠徒步回家。

对于第四天，Yazid 可以坐车先到达2 号节点，再步行回家。

第五天所有的边都积水了，因此Yazid 只能纯靠徒步回家。

本组数据强制在线。

第一天的答案是 0，因此第二天的v=(5+0−1)mod5+1=5，p=(2+0)mod(3+1)=2。

第二天的答案是 2，因此第三天的v=(2+2−1)mod5+1=4，p=(0+2)mod(3+1)=2。

第三天的答案是 3，因此第四天的v=(4+3−1)mod5+1=2，p=(0+3)mod(3+1)=3。

所有测试点均保证 T≤3，所有测试点中的所有数据均满足如下限制：

n≤2×105，m≤4×105，Q≤4×105，K∈{0,1}，1≤S≤109。
对于所有边： 10^9a≤109。
任意两点之间都直接或间接通过边相连。

为了方便你快速理解，我们在表格中使用了一些简单易懂的表述。在此，我们对这些内容作形式化的说明：

图形态：对于表格中该项为“一棵树”或“一条链”的测试点，保证m = n-1。除此之外，这两类测试点分别满足如下限制：
一棵树：保证输入的图是一棵树，即保证边不会构成回路。
一条链：保证所有边满足u + 1 = v。
海拔：对于表格中该项为“一种”的测试点，保证对于所有边有a = 1。
强制在线：对于表格中该项为“是”的测试点，保证K = 1；如果该项为“否”，则有K = 0。
对于所有测试点，如果上述对应项为“不保证”，则对该项内容不作任何保证。

n	m	Q=	测试点	形态	海拔	强制在线
≤1	≤0	0	1	不保证	一种	否
≤6	≤10	10	2	不保证	一种	否
≤50	≤150	100	3	不保证	一种	否
≤100	≤300	200	4	不保证	一种	否
≤1500	≤4000	2000	5	不保证	一种	否
≤200000	≤400000	100000	6	不保证	一种	否
≤1500	=n−1	2000	7	一条链	不保证	否
≤1500	=n−1	2000	8	一条链	不保证	否
≤1500	=n−1	2000	9	一条链	不保证	否
≤200000	=n−1	100000	10	一棵树	不保证	否
≤200000	=n−1	100000	11	一棵树	不保证	是
≤200000	≤400000	100000	12	不保证	不保证	否
≤200000	≤400000	100000	13	不保证	不保证	否
≤200000	≤400000	100000	14	不保证	不保证	否
≤1500	≤4000	2000	15	不保证	不保证	是
≤1500	≤4000	2000	16	不保证	不保证	是
≤200000	≤400000	100000	17	不保证	不保证	是
≤200000	≤400000	100000	18	不保证	不保证	是
≤200000	≤400000	400000	19	不保证	不保证	是
≤200000	≤400000	400000	20	不保证	不保证	是

　　这题有两种做法，一种是可持久化并查集+堆优化dijkstra，另一种是kruskal重构树+倍增+堆优化dijkstra。但大体思路都是一样的。首先想最暴力的方法，对于每一天，我们只要求出出发点坐车能到达的所有点，然后从这些点中选择距离1节点最近的点走到1节点就是答案。对于每个点距离1节点的最短距离，求一下最短路就好了，堆优化dijkstra跑一边就完事啦。为什么不用SPFA？呵呵，不妨告诉你，稳稳的TLE。所以现在剩下的问题就是如何快速求出每个点能到达哪些点？因为一定是走海拔高的边，所以建出全图的最大生成树就能保证两点间路径上的边尽可能大了。如果用可持久化并查集只要按边权顺序连边维护连通性，查询时找对应版本中出发点的联通块就好了(按点到1节点的最短路大小合并)，但这么写是O(nlog²n)，代码也比较长，并不是今天要说的重点(不是重点说这么多干嘛)。最优的做法是kruskal重构树，这是什么呢？就是把kruskal求出的最大生成树按边从大到小顺序，将边变成新建的一个点，点权就是原生成树这条边的边权(正常的是最小生成树，按边权从小到大建)，并将这条边的两个端点在重构树中的所属子树的当前根节点分别连到这个新建点上作为这个点的左右子节点。建完的这棵新树就是kruskal重构树。

kruskal重构树有许多很好的性质：

1、它是一个小根堆(因为是按边权从大到小加边)

2、它还是一个二叉树

3、这棵树所有的非叶子节点都是原树的边，所有的叶子结点是原树的点。

4、重构树上任意两个叶子结点的LCA就是原树上这两个点间的边

5、重构树上任意一个非叶子节点的子树中的所有叶子结点(也就是原树中的点)中任意两个节点在原树中路径上的最小边都大于等于这个非叶子节点的点权。

有了最后的那条性质，这道题就解决了！每次询问只要在重构树上从询问点往上倍增走到点权最小的大于当天水位线的那个点，那个点子树中所有叶子节点就都是当天出发点坐车能到达的点，找到这些点中到1节点最短路最小的就是答案了。这个可以直接在重构树上维护每个点子树中最短路最小值。

#include<set>

#include<map>

#include<queue>

#include<stack>

#include<cmath>

#include<cstdio>

#include<vector>

#include<cstring>

#include<iostream>

#include<algorithm>

#define ll long long

using namespace std;

typedef pair<int,int> pr;

ll ans;

int tot;

int cnt;

int n,m;

int T,t;

int k,S;

int x,y,z,w;

ll d[1600010];

ll mn[1600010];

int f[1600010];

int v[1600010];

int ls[1600010];

int rs[1600010];

int to[1600010];

int vis[1600010];

int val[1600010];

int head[1600010];

int next[1600010];

int g[1600010][21];

ll INF=1ll<<60;

struct node

{

    int u;

    int v;

    int s;

}a[1600010];

void add(int x,int y,int z)

{

    tot++;

    next[tot]=head[x];

    head[x]=tot;

    to[tot]=y;

    val[tot]=z;

}

int find(int x)

{

    if(f[x]==x)

    {

        return x;

    }

    return f[x]=find(f[x]);

}

bool cmp(node a,node b)

{

    return a.s>b.s;

}

void dijkstra(int st)

{

    priority_queue< pr,vector<pr>,greater<pr> >q;

    for(int i=1;i<=n;i++)

    {

        d[i]=INF;

    }

    d[st]=0;

    q.push(make_pair(d[st],st));

    while(!q.empty())

    {

        int now=q.top().second;

        q.pop();

        if(vis[now])

        {

            continue;

        }

        vis[now]=1;

        for(int i=head[now];i;i=next[i])

        {

            if(d[to[i]]>d[now]+val[i])

            {

                d[to[i]]=d[now]+val[i];

                q.push(make_pair(d[to[i]],to[i]));

            }

        }

    }

    for(int i=1;i<=n;i++)

    {

        mn[i]=d[i];

    }

}

void dfs(int x)

{

    ll res=INF;

    for(int i=1;i<=20;i++)

    {

        g[x][i]=g[g[x][i-1]][i-1];

    }

    if(x<=n)

    {

        return ;

    }

    if(ls[x])

    {

        dfs(ls[x]);

        res=min(res,mn[ls[x]]);

    }

    if(rs[x])

    {

        dfs(rs[x]);

        res=min(res,mn[rs[x]]);

    }

    mn[x]=res;

    return ;

}

int ST(int x,int mx)

{

    for(int i=20;i>=0;i--)

    {

        if(v[g[x][i]]>mx&&g[x][i]!=0)

        {

            x=g[x][i];

        }

    }

    return x;

}

int main()

{

    scanf("%d",&T);

    while(T--)

    {

        cnt=0;

        tot=0;

        ans=0;

        memset(head,0,sizeof(head));

        memset(mn,0,sizeof(mn));

        memset(v,0,sizeof(v));

        memset(ls,0,sizeof(ls));

        memset(rs,0,sizeof(rs));

        memset(g,0,sizeof(g));

        memset(vis,0,sizeof(vis));

        scanf("%d%d",&n,&m);

        for(int i=1;i<=m;i++)

        {

            scanf("%d%d%d%d",&x,&y,&z,&w);

            add(x,y,z);

            add(y,x,z);

            a[i].u=x;

            a[i].v=y;

            a[i].s=w;

        }

        dijkstra(1);

        for(int i=1;i<=n*2;i++)

        {

            f[i]=i;

        }

        sort(a+1,a+1+m,cmp);

        cnt=n;

        for(int i=1;i<=m;i++)

        {

            int fx=find(a[i].u);

            int fy=find(a[i].v);

            if(fx!=fy)

            {

                cnt++;

                v[cnt]=a[i].s;

                ls[cnt]=fx;

                rs[cnt]=fy;

                g[fx][0]=cnt;

                g[fy][0]=cnt;

                f[fx]=cnt;

                f[fy]=cnt;

                if(cnt==2*n-1)

                {

                    break;

                }

            }

        }

        dfs(cnt);

        scanf("%d%d%d",&t,&k,&S);

        while(t--)

        {

            scanf("%d%d",&x,&y);

            x=(x+k*ans-1)%n+1;

            y=(y+k*ans)%(S+1);

            ans=mn[ST(x,y)];

            printf("%lld\n",ans);

        }

    }

}