【NOI2018】归程（kruskal重构树）

这道题最后会化为这么一个问题：给一张图，每条边都有边权，多组询问，每次给出 $u,k$，问从 $u$ 开始走，只走边权 $\le k$ 的边，请维护 $u$ 能走到的点的集合。

这就需要用到一种叫 kruskal 重构树的东东。

首先可以发现，若 $u$ 能走到 $v$，那么 $u$ 在最小生成树上也必然能走到 $v$，所以我们只需要在原图的最小生成树上面走即可。

我们考虑用 kruskal 算法构建最小生成树时的过程：假设当前枚举到的边的两个端点所在连通块不同（设这两个连通块的根分别是 $a,b$），那么我们就新建立一个虚点 $c$，令 $c$ 为 $a,b$ 的父亲，令 $c$ 的点权为这条边的边权。这也就是相当于把构建并查集的过程给描述出来。

这样建出来的树有许多很好的性质：

• 这是一棵完全二叉树。

• 树上的每一个叶子节点对应着最小生成树上的点（即原图的点），每一个非叶子节点对应着最小生成树上的边。

• 父亲节点的点权大于等于儿子节点的点权（儿子节点非叶子节点），于是这也是一个二叉堆。

• 两点 $u,v$ 的 $lca$ 的点权即为最小生成树上 $u$ 到 $v$ 路径上的最大边权，但注意两点 $u,v$ 在 kruskal 重构树上的路径所经过的所有非叶子节点所代表的边并不是 $u,v$ 在最小生成树上的路径所经过的边。

  对于某个非叶子节点 $u$，若 $u$ 的权值严格小于其父亲的权值（加上这个条件是因为有相同边权的存在），那么 $u$ 的子树内的所有叶子节点所代表的点就是最小生成树上从 $u$ 所代表的的边 $e$ 出发、不经过权值比 $e$ 大的边所能到达的所有点。

• ……

那么我们可以先把 kruskal 重构树建出来，然后每次询问时用倍增找到 $u$ 的最远的权值小于等于 $k$ 的祖先 $f$，那么 $f$ 子树内的所有叶子节点即为最小生成树上 $u$ 能到达的所有点。

整题的代码如下：

#include<bits/stdc++.h>

#define LN 19
#define N 200010
#define M 400010
#define lc(u) ch[u][0]
#define rc(u) ch[u][1]

using namespace std;

inline int read()
{
	int x=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-') f=-1;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=(x<<1)+(x<<3)+(ch^'0');
		ch=getchar();
	}
	return x*f;
}

struct Edge
{
	int u,v,w;
	Edge(){};
	Edge(int a,int b,int c){u=a,v=b,w=c;}
}e[M];

bool operator < (Edge a,Edge b)
{
	return a.w>b.w;
}

struct data
{
	int u,s;
	data(){};
	data(int a,int b){u=a,s=b;}
	bool operator < (const data &a) const
	{
		return s>a.s;
	}
};

int t,n,m,Q,k,s;
int cnt,head[N],nxt[M<<1],to[M<<1],w[M<<1];
int dis[N];
int rt,node,ch[N<<1][2];
int d[N<<1],fa[N<<1][LN],val[N<<1],minn[N<<1];
int f[N<<1];
bool vis[N];

priority_queue<data>q;

void adde(int u,int v,int wi)
{
	to[++cnt]=v;
	w[cnt]=wi;
	nxt[cnt]=head[u];
	head[u]=cnt;
}

void dijkstra()
{
	memset(vis,0,sizeof(vis));
	memset(dis,127,sizeof(dis));
	dis[1]=0;
	q.push(data(1,0));
	while(!q.empty())
	{
		data now=q.top();
		q.pop();
		if(vis[now.u]) continue;
		vis[now.u]=1;
		for(int i=head[now.u];i;i=nxt[i])
		{
			int v=to[i];
			if(dis[now.u]+w[i]<dis[v])
			{
				dis[v]=dis[now.u]+w[i];
				q.push(data(v,dis[v]));
			}
		}
	}
}

int find(int x)
{
	return x==f[x]?x:(f[x]=find(f[x]));
}

void dfs(int u)
{
	for(int i=1;i<=18;i++)
		fa[u][i]=fa[fa[u][i-1]][i-1];
	if(!lc(u)&&!rc(u))
	{
		minn[u]=dis[u];
		return;
	}
	fa[lc(u)][0]=fa[rc(u)][0]=u;
	dfs(lc(u)),dfs(rc(u));
	minn[u]=min(minn[lc(u)],minn[rc(u)]);
}

int query(int u,int x)
{
	for(int i=18;i>=0;i--)
		if(fa[u][i]&&val[fa[u][i]]>x)
			u=fa[u][i];
	return minn[u];
}

int main()
{
	t=read();
	while(t--)
	{
		cnt=0;
		memset(head,0,sizeof(head));
		n=read(),m=read();
		for(int i=1;i<=m;i++)
		{
			int u=read(),v=read(),l=read(),a=read();
			adde(u,v,l),adde(v,u,l);
			e[i]=Edge(u,v,a);
		}
		dijkstra();
		sort(e+1,e+m+1);
		for(int i=1;i<=n;i++) f[i]=i,lc(i)=rc(i)=0;
		node=n;
		for(int i=1,tot=0;tot<n-1;i++)
		{
			int a=find(e[i].u),b=find(e[i].v);
			if(a!=b)
			{
				node++;
				val[node]=e[i].w;
				f[a]=f[b]=f[node]=node;
				lc(node)=a,rc(node)=b;
				tot++;
			}
		}
		rt=node;
		fa[rt][0]=0,d[rt]=1;
		dfs(rt);
		Q=read(),k=read(),s=read();
		int lans=0;
		while(Q--)
		{
			int u=read(),x=read();
			u=(u+k*lans-1)%n+1;
			x=(x+k*lans)%(s+1);
			printf("%d\n",lans=query(u,x));
		}
	}
	return 0;
}