LCT 小记

全程 Link-Cut Tree，是解决动态树问题的有力科技

——题记

简单实现

LCT 的形态直观上是一堆 Splay 的合体，每个 Splay 以时间戳为关键字，各个 Splay 通过虚边相连，可以唯一还原出一棵树

Splay 的划分依据为实链剖分，即在一条实链上的点放到一棵 Splay 里面，其他关联点通过虚边和其他 Splay 连接

一条虚边体现为儿子的父亲认做父亲，而父亲是不认这个儿子的

首先得先写 Splay 对吧，唯二不同的是 Splay 之前先跳到根把所有懒标记下放，以及旋转是不能贸然让父亲认儿子，需要判断是不是虚边

核心函数 —— $access(x)$ 操作
经过这个操作后可以把 $x$ 这个节点与整棵树的树根划分在一条实链里（即一棵 Splay 里），并且这条链在 $x$ 处结束

至于具体怎么弄就不说了，反正代码异常简洁

void access(int x){
	for(int y=0;x;y=x,x=fa[x]){
		splay(x);
		son[x][1]=y;
		update(x);
	}
	return ;
}

$makeroot(x)$ 操作 —— 将 $x$ 弄到整棵树的树根

先 $access$ ，再 $splay$ ，这时虽然它到了平衡树的顶部，由于存在左儿子，它的时间戳没变
这是用一个神奇的操作 —— $reverse$ ，就像文艺平衡树那样把它两个儿子颠倒一下，这个也需要通过打懒标记依次下放

$link(x,y)$ 操作 —— 将两个点所在的树合并
把 $x$ 转到它那棵树的根，直接认 $y$ 当爹即可

$cut(x,y)$ 操作 —— 将两个点间的连边删除
把 $x$ 弄到根上，把 $y$ 和它打通，再把 $y$ 转到根上，由于它们在树上是相邻的，这时的状态一定是 Splay 里只有它们两个，直接不认父亲和不认儿子即可
（注：这里的“弄”指的是 $makeroot$ ，这里的“转”指的是 $splay$ ，习惯上代码里把前三步重新封装到一个 $split$ 函数里）

这些就是核心函数了，对于询问，常形如“从 $x$ 到 $y$ 的路径上的 xxx 信息”
这时只需要做一遍 $split$ 操作， $y$ 节点上的信息就是链上的信息

这里放一下洛谷模板题的代码，背熟即可：

代码

#include<bits/stdc++.h>
using namespace std;
int n,m,op,x,y;
int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-')f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=x*10+ch-48;
		ch=getchar();	
	}
	return x*f;
}
namespace LCT{
	const int maxn=2e5+5;
	int fa[maxn],son[maxn][2];
	int rev[maxn],val[maxn],sum[maxn];
	int sta[maxn],tp;
	
	void update(int x){
		sum[x]=sum[son[x][0]]^sum[son[x][1]]^val[x];
		return ;
	}
	void push_rev(int x){
		rev[x]^=1;
		swap(son[x][0],son[x][1]);
		return ;	
	}
	void down(int x){
		if(rev[x]){
			push_rev(son[x][0]);
			push_rev(son[x][1]);
			rev[x]=0;	
		}
		return ;
	}
	bool get(int x){
		return son[fa[x]][1]==x;	
	}
	bool isroot(int x){
		return son[fa[x]][0]!=x&&son[fa[x]][1]!=x;	
	}
	void rotate(int x){
		int f1=fa[x];
		int f2=fa[f1];
		bool id=get(x);
		son[f1][id]=son[x][id^1];
		fa[son[f1][id]]=f1;
		if(!isroot(f1))son[f2][get(f1)]=x;
		fa[x]=f2;
		son[x][id^1]=f1;
		fa[f1]=x;
		update(f1);
		return ;
	}
	void splay(int x){
		tp=0;
		int y=x;
		sta[++tp]=y;
		while(!isroot(y))sta[++tp]=y=fa[y];
		while(tp)down(sta[tp--]);
		while(!isroot(x)){
			int f1=fa[x];
			int f2=fa[f1];
			if(!isroot(f1)){
				rotate(get(x)==get(f1)?f1:x);
			}
			rotate(x);
		}
		update(x);
		return ;
	}
	void access(int x){
		for(int y=0;x;y=x,x=fa[x]){
			splay(x);
			son[x][1]=y;
			update(x);
		}
		return ;
	}
	void makeroot(int x){
		access(x);
		splay(x);
		push_rev(x);
		return ;	
	}
	void split(int x,int y){
		makeroot(x);
		access(y);
		splay(y);	
	}
	int findroot(int x){
		access(x);
		splay(x);
		while(son[x][0])x=son[x][0];
		splay(x);
		return x;	
	}
	void link(int x,int y){
		makeroot(x);
		if(findroot(y)!=x)fa[x]=y;
		return ;	
	}
	void cut(int x,int y){
		split(x,y);	
		if(son[y][0]==x){
			son[y][0]=fa[x]=0;
			update(y);	
		}
		return ;
	}
	int ask(int x,int y){
		split(x,y);
		return sum[y];
	}
	void modify(int x,int w){
		splay(x);
		val[x]=w;
		update(x);
		return ;	
	}
}
int main(){
	n=read();
	m=read();
	for(int i=1;i<=n;i++){
		LCT::val[i]=read();	
	}
	for(int i=1;i<=m;i++){
		op=read();
		x=read();
		y=read();
		switch (op){
			case 0:
				printf("%d\n",LCT::ask(x,y));
				break;
			case 1:
				LCT::link(x,y);
				break;
			case 2:
				LCT::cut(x,y);
				break;
			case 3:
				LCT::modify(x,y);
		}
	}
	return 0;
}