[OI] Kruskal 重构树

算法介绍

Kruskal 重构树用于快速判断节点的连通性.

考虑到，假如两个节点是联通的，则他们之间总会有一条边被选入最小生成树内，因此他们在最小生成树内也是联通的. 也就是说，我们可以通过求最小生成树来减少我们判断联通需要的边数.

Kruskal 重构树的思想是这样的：假如有一条生成树边 \((x,y)\)，则断开 \((x,y)\)，新建一个虚电 \(i\)，连接 \((x,i),(y,i)\)，在这样操作后，因为原生成树即为一棵树，因此新构成的图也是一棵树，并且树上任意一点的子树中的所有节点总是可达的. 这个操作可以在求生成树时同时进行.

对于带权的边，我们可以把边权直接放到点上. 注意到这样构造出来的重构树一定是二叉堆. 并且任意两点路径边权最大值为重构树上LCA的点权.

为什么是最大值？考虑到我们构建最小生成树的过程，最大的边一定会后选. 在考虑我们构建重构树的过程，后选的边总是作为新的父节点，因此两点的 LCA 即为两点间路径中最后选的那一个，即边权最大值.

注意到这一块可能是需要爆改的，改这个主要使用改最小生成树来实现，学长说跑什么生成树是需要变通的，比如要求最小边权就需要跑最大生成树，有时候还需要跑特殊生成树，只不过这个算法的思想是借助的 Kruskal 的，所以我们用最小生成树当例子.

首先新建 \(n\) 个集合，每个集合恰有一个节点，点权为 \(0\)

每一次加边会合并两个集合，我们可以新建一个点，点权为加入边的边权，同时将两个集合的根节点分别设为新建点的左儿子和右儿子。然后我们将两个集合和新建点合并成一个集合。将新建点设为根

此处模板使用 \(\gt n\) 的点作为虚点.

void Kruskal(){
	for(int i=1;i<=n;i++){
		fa[i]=i;
	}
	int cnt=0;
	sort(e+1,e+n+1);
	for(int i=1;i<=m;i++){
    	int x=e[i].x, y=e[i].y, w=e[i].w;
    	int fx=find(x),fy=find(y);
    	if(fx^fy){
        	val[++cnt+n]=w;
			fa[fx]=fa[fy]=fa[cnt+n]=now;
        	e[cnt+n].push_back({fx,1});
        	e[cnt+n].push_back({fy,1});
    	}
	}
}

CF1706E Qpwoeirut and Vertices

这个题涉及到了重构树求最值的问题，写了比较有启发意义的爆改线段树

此题可以将时间戳设计成点权，考虑到重构树的特殊性质，我们可以将其按时间戳全部联通，根据任意两点路径边权最大值为重构树上LCA的点权，此题我们需要求的正好就是边权最大值，因此直接维护树上 LCA 即可. 取最值可以用 st 表或线段树.

这里没排序是因为时间戳是有序的，用的线段树来维护，更新子节点节点最大权值的时候也可以直接 LCA 解决，比较方便，只是常数比 LCA 大.

#include<bits/stdc++.h>
using namespace std;
int n,m,q,tot;
namespace dsu{
	int fa[300001];
	inline void clear(){
		for(register int i=1;i<=n+m;++i){
			fa[i]=i;
		}
	}
	inline int find(int id){
		if(id==fa[id]) return id;
		fa[id]=find(fa[id]);
		return fa[id];
	}
}
vector<int>e[300001];
namespace lca{
	int fa[20][300001],deep[300001];
	inline void dfs(int now){
		for(int i=1;i<=19;++i){
			fa[i][now]=fa[i-1][fa[i-1][now]];
		}
		for(int i:e[now]){
			deep[i]=deep[now]+1;
			fa[0][i]=now;
			dfs(i);
		}
	}
	inline void prework(){
		for(register int i=1;i<=19;++i){
			for(register int j=1;j<=n+m;++j){
				fa[i][j]=fa[i-1][fa[i-1][j]];
			}
		}
	}
	inline int lca(int x,int y){
		if(deep[x]<deep[y]) swap(x,y);
		for(register int i=19;i>=0;--i){
			if((deep[x]-deep[y])>=(1ll<<i)){
				x=fa[i][x];
			}
		}
		if(x==y) return x;
		for(register int i=19;i>=0;--i){
			if(fa[i][x]!=fa[i][y]){
				x=fa[i][x];y=fa[i][y];
			}
		}
		return x==y?x:fa[0][x];
	}
}
namespace stree{
	#define tol (id*2)
	#define tor (id*2+1)
	#define mid(x,y) mid=((x)+(y))/2
	struct tree{
		int l,r,w;
	}t[400001];
	inline void build(int id,int l,int r){
		t[id].l=l,t[id].r=r;if(l==r){
			t[id].w=l;
			return;
		}
		int mid(l,r);
		build(tol,l,mid);
		build(tor,mid+1,r);
		t[id].w=lca::lca(t[tol].w,t[tor].w);
	}
	inline int ask(int id,int l,int r){
		if(t[id].l==l and t[id].r==r) return t[id].w;
		int mid(t[id].l,t[id].r);
		if(r<=mid) return ask(tol,l,r);
		if(l>=mid+1) return ask(tor,l,r);
		return lca::lca(ask(tol,l,mid),ask(tor,mid+1,r));
	}
}
namespace hdk{
    namespace Iter{
		void cout(std::vector<int> &_v,int _from,int _to,char _devide){std::vector<int>::iterator iter;std::vector<int>::reverse_iterator riter;
		if(_from<_to){for(iter=_v.begin()+_from;iter!=_v.begin()+_to;++iter){std::cout<<*iter<<_devide;}}
		else{for(riter=_v.rbegin()+_to;riter!=_v.rbegin()+_from;++riter){std::cout<<*riter<<_devide;}}}
	}
	template<typename T>
	void memset(T a[],int _val,int _size){if(_val==0){for(T* i=a;i<=a+_size-1;++i) *i&=0;return;}for(T* i=a;i<=a+_size-1;++i)*i=_val;}
	namespace fastio{
		void rule(bool setting=false){std::ios::sync_with_stdio(setting);}
		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^48);ch=getchar();}return x*f;}
	    inline int read(int &A){A=read();return A;}
        inline char read(char &A){A=getchar();return A;}
		inline void write(int A){if(A<0){putchar('-');A=-A;}if(A>9){write(A/10);}putchar(A%10+'0');}
        inline void write(long long A){if(A<0){putchar('-');A=-A;}if(A>9){write(A/10);}putchar(A%10+'0');}
		inline void write(char A){putchar(A);}
		inline void space(){putchar(' ');}
		inline void endl(){putchar('\n');}
		#define w(a) write(a)
		#define we(a) write(a);endl()
		#define ws(a) write(a);space()
	}
}
using namespace hdk::fastio;
int main(){
//	freopen("lagrange1.in","r",stdin);
//	freopen("hdk.out","w",stdout);
	int cases;read(cases);while(cases--){
		read(n);read(m);read(q);
		tot=0;
		dsu::clear();
		for(int i=1;i<=n+m;++i){
			e[i].clear();
		}
		for(register int i=1;i<=m;++i){
			int x,y;read(x);read(y);
			int fx=dsu::find(x),fy=dsu::find(y);
			if(fx==fy) continue;
			e[i+n].push_back(fx);
			e[i+n].push_back(fy);
			dsu::fa[fx]=dsu::fa[fy]=i+n;
			tot=i+n;
		}
		lca::deep[tot]=1;
		lca::dfs(tot);
	//	lca::prework();
		stree::build(1,1,n);
		for(register int i=1;i<=q;++i){
			int l,r;l=read();r=read();
			if(l^r){
				ws(stree::ask(1,l,r)-n);
			}
			else{
				putchar('0');putchar(' ');
			}
		}
		endl();
	}
}

[NOI2018] 归程

纪念这个题把我打破防了

本题就是刚才说的那种跑最大生成树的题，而且这个题比较巧妙，跑的是关于海拔的最大生成树. 首先跑之前先把单源最短路求出来，其次按上面的套路重构出一个关于海拔的重构树，因为是最大生成树，因此可以求到路径最小值，我们需要的就是这个，因此根据路径最小值去爆搜一遍.

这道题把倍增放在询问里用，因为这个题显然是求出距离来剩下的暴跳就行了，所以 倍增主要是用来暴跳的而不是用来 LCA 的

#include<bits/stdc++.h>
using namespace std;
const int N=800001;
int n,m;
struct edge{
	int to,w;
};
vector<edge>e[N];
struct aedge{
	int x,y,l;
	bool operator <(const aedge &A)const{
		return l>A.l;
	}
}E[N];
struct node{
	int id,w;
	bool operator <(const node &A)const{
		return w>A.w;
	}
};
int fa[N][21],_min[N],val[N];
namespace dsu{
	int fa[N];
	void clear(int n){
		for(int i=1;i<=n;++i){
			fa[i]=i;
		}
	}
	int find(int id){
		if(id==fa[id]) return id;
		fa[id]=find(fa[id]);
		return fa[id];
	}
}
namespace DIJKSTRA{
	int vis[N],dis[N];
	priority_queue<node>q;
	void dij(){
		memset(vis,0,sizeof vis);
		memset(dis,0x3f,sizeof dis);
		vis[1]=1;dis[1]=0;
		q.push({1,dis[1]});
		while(!q.empty()){
			node u=q.top();q.pop();
			for(edge i:e[u.id]){
				if(dis[i.to]>dis[u.id]+i.w){
					dis[i.to]=dis[u.id]+i.w;
					q.push({i.to,dis[i.to]});
				}
			}
		}
	}
}
bool vvis[N];
void dfs(int now,int last){
	if(vvis[now]) return;
	vvis[now]=true;
	fa[now][0]=last;
	_min[now]=DIJKSTRA::dis[now];
	for(int i=1;i<=20;++i){
		fa[now][i]=fa[fa[now][i-1]][i-1];
	}
	for(edge i:e[now]){
		if(i.to!=last){
			dfs(i.to,now);
			_min[now]=min(_min[now],_min[i.to]);
		}
	}
}
int cnt;
int main(){
	int cases;scanf("%d",&cases);while(cases--){
		scanf("%d %d",&n,&m);
		memset(_min,0,sizeof _min);
		memset(fa,0,sizeof fa);
		for(int i=1;i<=N;++i){
			e[i].clear();
		}
		for(int i=1;i<=m;++i){
			int x,y,l,a;scanf("%d %d %d %d",&x,&y,&l,&a);
			E[i]={x,y,a};
			e[x].push_back({y,l});
			e[y].push_back({x,l});
		}
		DIJKSTRA::dij();
		sort(E+1,E+m+1);
		dsu::clear(N);
		for(int i=1;i<=N;++i){
			e[i].clear();
		}
		int now=n;
		for(int i=1;i<=m;++i){
			int x=E[i].x,y=E[i].y,w=E[i].l;
			int fx=dsu::find(x);
			int fy=dsu::find(y);
			if(fx^fy){
				val[++now]=w;
				dsu::fa[fx]=dsu::fa[fy]=dsu::fa[now]=now;
				e[now].push_back({fx,1});
				e[now].push_back({fy,1});
			}
		}
		memset(vvis,false,sizeof vvis);
		dfs(now,0);
		int last=0;
		int q,k,s;scanf("%d %d %d",&q,&k,&s);
		for(int i=1;i<=q;++i){
			int x,y,v,p;
			scanf("%d %d",&x,&y);
			v=(x+k*last-1)%n+1;
			p=(y+k*last)%(s+1);
			for(int j=20;j>=0;--j){
				if(fa[v][j] and val[fa[v][j]]>p) v=fa[v][j];
			}
			printf("%d\n",last=_min[v]);
		}
	}
}