P4768 [NOI2018]归程（kruskal 重构树）

洛谷P4768 [NOI2018]归程

LOJ#2718.「NOI2018」归程

用到 kruskal 重构树，所以先说这是个啥

显然，这和 kruskal 算法有关系 （废话

这个重构树是一个有点权的树

以最小生成树为例，当然最大也一样

先把所有原有的节点点权赋为 \(0\)

在跑 kruskal 的时候，我们没求出一条当前权值最小，且两端点不在同一集合的边时（并查集，kruskal 常规操作），我们就选这条边，然后把两端点划分在同一集合

不过上面仅仅时 kruskal 的操作，另外，我们还要在新建一个节点，把这个新节点作为父亲，这条被选择的边的两个端点，在并查集中的根，就是他的两个儿子

新建节点的点权，就是当前选的这条边的边权

然后合并集合的时候，要把新建的这个节点，和两个端点都合并在一个集合中，并且，把新建节点作为根（根说的就是并查集的最早祖先）

这样，以节点 \(x\) 为根的集合中的所有点，都在以 \(x\) 为根的树上

这样，每选择一条边，都会新建一个集合（就是新的那个节点，这个节点的集合一建立就被和其它的合并了，但是不妨还是理解为先建立），合并三个集合，也就是集合总数少了一个

那么选 \(n-1\) 条边（显然这就是最小生成树上的所有边），就会得到一个集合，这个集合的根就是重构树的根，如果从 \(n+1\) 开始为新建的节点编号，那么根的编号就是 \(2n-1\)

此时，新构建出的这个树，就是 kruskal 重构树

举个栗子，有如下一张图

它的最小生成树是这样的：

那么它的重构树是这样的

考虑一下它有哪些性质

• 是一棵二叉树，并且每个非叶子节点都有两个儿子，观察刚才构建原则，很显然
• 一个节点在重构树中是叶子节点，等价于这个节点是原有的节点，也很显然
• 在树上的任意一条上下的链上（直上直下，不能在中间某个节点拐弯），如果是在求最小生成树时重构的，点权从下到上不减，如果时求最大生成树时重构的，不考虑叶子节点，是不增
  
  这点是很显然的，以最小生成树为例，我们总是先选择权值小的边，创建的点的点权小，然后没次新创建的点，总是在已经创建的（或者原有的）点的上面，所以一条链上总是上面的点点权更大（或相同）
• 容易发现，最小生成树上两个点之间，树上路径中，最大边权就是重构树中，两点 LCA 的点权（最大生成树中最小边权也一样，下面就不再分类说了）
• 通过上一条，可以知道，到节点 \(v\) 的树上路径中的最大值，小于某个值的所有节点 \(u\)，都在同一个子树内
  
  再由第二条性质，都是这个子树内的叶子节点
• 由上一条继续推，就能知道，这个子树的根，就是 从 \(v\) 到整个重构树的根的路径中，深度最小的，点权小于这个值的节点
  
  一般来说，又因为这个路径上的点圈不减，所以这个节点可以预处理一个倍增数组，来求出，下面要说的那个题就用到这个方法

基本上就是这些了，下面来看 [NOI2018]归程 这题

---

kruskal 重构树+倍增+dij 最短路

不算太难，当kruskal 重构树上手题比较好

话说当年应该就是这题宣布了 SPFA 的死亡（（（

---

由于开车只能走海拔比某个值大的边，所以我们应该按照海拔，给原图求一个最大生成树的 kruskal 重构树

由上面的性质，可以 \(\log n\) 内求出所有开车能达到的节点，都在重构树中哪个节点的子树中

因为要求走路走的最短，所以用 SPFA 用 dijkstra 求出 \(1\) 到每个点的最短路（按照长度）

然后，在对重构树进行预处理 dfs 时，不光要求出倍增数组，还要求出当前节点 \(u\) 的子树中，到 \(1\) 的最短路最小的点的最短路长度

所以，用倍增跳到从起点，到整个重构树的根的路径中，深度最小的，点权大于这个值（就是水位线）的节点

然后答案就是这个点的子树中，到 \(1\) 的最短路径长度

然后，就做完了，我会做noi2018的题了，耶

自己犯的傻：

多测不清零，5分两行泪

数组没二倍（重构树有 \(2n-1\) 个节点），50分两行泪

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<map>
#include<iomanip>
#include<cstring>
#define reg register
#define EN std::puts("")
#define LL long long
inline int read(){
	register int x=0;register int y=1;
	register char c=std::getchar();
	while(c<'0'||c>'9'){if(c=='-') y=0;c=std::getchar();}
	while(c>='0'&&c<='9'){x=x*10+(c^48);c=std::getchar();}
	return y?x:-x;
}
#define N 200006
#define M 800006
int n,m,vertex;
inline int get_min(int x,int y){return x<y?x:y;}
struct graph{
	int fir[N],nex[M],to[M],w[M],tot;
	inline void add(int u,int v,int len){
		to[++tot]=v;w[tot]=len;
		nex[tot]=fir[u];fir[u]=tot;
	}
	inline void clear(){
		std::memset(fir,0,sizeof fir);std::memset(nex,0,sizeof nex);
		tot=0;
	}
}G;
struct shortest_path{
	int dis[N],heap[N],size,in[N];
	inline void push(int x){
		heap[++size]=x;
		reg int i=size,fa;
		while(i>1){
			fa=i>>1;
			if(dis[heap[fa]]<=dis[heap[i]]) return;
			std::swap(heap[fa],heap[i]);i=fa;
		}
	}
	inline int pop(){
		int ret=heap[1];heap[1]=heap[size--];
		int i=1,ls,rs;
		while((i<<1)<=size){
			ls=i<<1;rs=ls|1;
			if(rs<=size&&dis[heap[rs]]<dis[heap[ls]]) ls=rs;
			if(dis[heap[ls]]>=dis[heap[i]]) break;
			std::swap(heap[i],heap[ls]);i=ls;
		}
		return ret;
	}
	inline void dij(int start){
		std::memset(dis,0x3f,sizeof dis);dis[start]=0;
		push(start);in[start]=1;
		while(size){
			reg int u=pop();in[u]=0;
			for(reg int v,i=G.fir[u];i;i=G.nex[i]){
				v=G.to[i];
				if(dis[v]>dis[u]+G.w[i]){
					dis[v]=dis[u]+G.w[i];
					if(!in[v]) push(v),in[v]=1;
				}
			}
		}
	}
}path;
struct kruskal_tree{
	struct edge{
		int u,v,w;
	}e[M];
	inline int find(int k){
		return k==up[k]?k:up[k]=find(up[k]);
	}
	static inline int cmp(edge aa,edge aaa){return aa.w>aaa.w;}
	int up[N*2],son[2][N*2],val[N*2];
	int fa[23][N*2],min_dis[N*2];
	inline void kruskal(){
		std::sort(e+1,e+1+m,cmp);
		vertex=n;
		for(reg int i=1;i<n*2;i++) up[i]=i;
		for(reg int u,v,i=1,cnt=1;cnt<n;i++){
			u=find(e[i].u);v=find(e[i].v);
			if(u==v) continue;
			val[++vertex]=e[i].w;
			son[0][vertex]=u;son[1][vertex]=v;
			cnt++;up[u]=up[v]=vertex;
		}
	}
	void dfs(int u){
//			std::printf("now : %d\n",u);
		for(reg int i=1;i<20;i++) fa[i][u]=fa[i-1][fa[i-1][u]];
		min_dis[u]=u<=n?path.dis[u]:0x3f3f3f3f;
		if(son[0][u]){
			fa[0][son[0][u]]=u;
			dfs(son[0][u]);
			min_dis[u]=get_min(min_dis[u],min_dis[son[0][u]]);
		}
		if(son[1][u]){
			fa[0][son[1][u]]=u;
			dfs(son[1][u]);
			min_dis[u]=get_min(min_dis[u],min_dis[son[1][u]]);
		}
	}
	inline int get_min_dis(reg int u,reg int p){
		for(reg int i=19;~i;i--)
			if(val[fa[i][u]]>p) u=fa[i][u];
		return min_dis[u];
	}
}TREE;
inline void clear(){
	std::memset(TREE.fa,0,sizeof TREE.fa);std::memset(TREE.min_dis,0,sizeof TREE.min_dis);
	std::memset(TREE.val,0,sizeof TREE.val);std::memset(TREE.son,0,sizeof TREE.son);
	G.clear();
//		std::puts("\n\n---------------------------------------------\n\n");
}
int main(){
//	std::freopen("return.in","r",stdin);
//	std::freopen("return.out","w",stdout);
int CASES=read();while(CASES--){
	n=read();m=read();
	for(reg int w,i=1;i<=m;i++){
		TREE.e[i].u=read();TREE.e[i].v=read();w=read();TREE.e[i].w=read();
		G.add(TREE.e[i].u,TREE.e[i].v,w);G.add(TREE.e[i].v,TREE.e[i].u,w);
	}
	path.dij(1);
	TREE.kruskal();
	TREE.fa[0][vertex]=vertex;TREE.dfs(vertex);
	int q=read(),K=read(),S=read();
	reg int lastans=0,u,p;
	while(q--){
		u=(read()+(LL)K*lastans-1)%n+1;p=(read()+(LL)K*lastans)%(S+1);
		lastans=TREE.get_min_dis(u,p);
		std::printf("%d\n",lastans);
	}
	if(CASES) clear();
}
	return 0;
}