Link-Cut Tree(知识总结+板子整理)
思路来源
https://www.luogu.com.cn/blog/flashblog/solution-p3690
https://www.cnblogs.com/19992147orz/p/8206693.html
https://www.cnblogs.com/candy99/p/6271344.html
前置知识
splay：真正理解rotate、会区间翻转
树链剖分：轻重链的概念
心得
杭电多校LCT的题，被120队过，不学新知识不行了，哎……
强推第一篇洛谷题解，有图可供食用，感觉还是挺好的……
然而，蒟蒻还是学了4个多小时……
access(x)
打通x到当前根的路径，
打通之后，x和根在同一Splay里，且x是深度最大的点，
即把x到根的这几棵Splay直接的虚边变为实边，原先对应的实边改为虚边
具体操作：
先把x旋到根，Splay(x)，
并把x的右子树置空，c[x][1]=0，强行切断x和比x深度更大的点的连接
由于x少了一个右子树，更新x这个根节点维护的信息，pushup(x)
x从虚边跳到深度更浅的一棵Splay，不妨令y=f(x)，则跳到了y这个点
重复这个过程，把y旋到根，Splay(y)，
把y的右子树置空，变原实边为虚边，c[y][1]=0，表示切断y与y原来的右子树之间的连接，
将右子树置为上一个操作的Splay的根，变原虚边为实边，c[y][1]=x，表示连接y这棵Splay与x这棵Splay
事实上，由于是赋值语句，可以忽略置空这个操作
由于y换了一个右子树，更新y这个根节点维护的信息，pushup(y)
y跳到深度更浅的一棵Splay，重复上述过程，直至跳到原树的根
inline void access(int x){
for(int y=0;x;y=x,x=f[x])
splay(x),c[x][1]=y,pushup(x);//儿子变了，需要及时上传信息
}makeroot(x)
换根，把x定为原树的根，
实际上，先打通x与原来的根rt的Splay，access(x)
然后，将这棵Splay打一个区间翻转的标记，pushr(x)，
r[x]懒惰标记：下放时，x的儿子ls、rs的左右子树应当被交换，且其标记应翻转
由于原来的Splay是按深度增序维护的，
x作为深度最大的点，被Splay到根之后，x没有右子树，
打一个区间翻转的标记之后，左右子树互换，x最终没有左子树，
这表明x是这棵Splay里深度最小的点，起到了"本末倒置"的作用
相当于换了一个节点，将整棵树拽出来，有种提灯笼的感觉
inline void pushr(int x){//Splay区间翻转操作
swap(c[x][0],c[x][1]);
r[x]^=1;//r为区间翻转懒标记数组
}
inline void makeroot(int x){
access(x);splay(x);
pushr(x);
}findroot(x)
找到x所在的原树的树根，
主要用于判断x和y两个点是否在一棵树上，即连通性
先打通x到根rt，access(x)
再将x旋到根，splay(x)，保证复杂度
不断向左子树找，并沿途下放x的标记，保证x的左子树是翻转后的，
直至找到最左的点，这是深度最小的点，记为y，
splay(y)，并返回y的值
inline int findroot(R x){
access(x); splay(x);
while(c[x][0])pushdown(x),x=c[x][0];
//如要获得正确的原树树根，一定pushdown！详见下方update（关于findroot中pushdown的说明）
splay(x);//保证复杂度
return x;
}split(x,y)
将(x,y)在树上的路径，放到一个Splay里当实链
树上问题，常询问(x,y)点对之间的权值和/异或和之类，需要顾及两条链
先把其中一个点，不妨为x，换为根，makeroot(x)
再把y到根的Splay打通，access(y)，y是深度最大的点
把y旋到根，splay(y)，这样x及其余点都在y左子树里
inline void split(int x,int y){
makeroot(x);
access(y);splay(y);
}link(x,y)
连一条x-y的边，注意判断树上x-y间是否已经有边，
先把x指定为根，makeroot(x)，
再判一下x和y的连通性即可，findroot(y)==x，若连通再连边就成环了
否则说明x和y在两棵树上，令x这棵树引一条虚边到y即可，f[x]=y
inline bool link(int x,int y){
makeroot(x);
if(findroot(y)==x)return 0;//两点已经在同一子树中，再连边不合法，如果保证连边一定合法，则可省略本行
f[x]=y;
return 1;
}cut(x,y)
断开x-y在原树上的边，动态删边
①保证删边合法
先扒出(x,y)在树上的路径，split(x,y)，注意split里的操作
先makeroot(x)，此时x是原树的根，
再access(y)，打通y到x的路径，Splay里只有y到x的路径，
再Splay(y)，此时y在Splay里是根，
则x由于与y相连，深度比y小1，一定是y的直连左子树，
直接令f[x]=0，表示x的父亲不存在；
c[y][0]=0，表示y的左子树不存在，并更新y的信息，pushup(y)
inline void cut(int x,int y){
split(x,y);
f[x]=c[y][0]=0;
pushup(y);//少了个儿子，也要上传一下
}②删边不一定合法，即不能保证原树上x-y之间有边
先将x钦定为根，makeroot(x)
（1）判断一下y和x的连通性，若findroot(y)!=x，表示y和x在原树上不连通，无边，否则转（2）
（2）注意到（1）中执行了findroot(y)，其中包含access(y)和splay(y)和splay(x)，
现在x和y的路径被打通，x是Splay的根，Splay中只有x到y的路径，
若y在Splay中的直连父亲不是y，f[y]!=x，说明y和x之间还有别的点，否则转（3）
（3）此时f[y]==x已经成立，但可能y是x的右子树，y还有左子树，导致中序遍历时xy之间还有点，
所以如果ch[y][0]!=0，说明y和x之间还有别的点，否则说明这是合法的情况
inline bool cut(int x,int y){
makeroot(x);
if(findroot(y)!=x||f[y]!=x||c[y][0])return 0;
f[y]=c[x][1]=0;//x在findroot(y)后被转到了根
pushup(x);
return 1;
}合法的情况：x、y的Splay里只有x、y两个点，x为根，y为x的右子树
所以，如果维护了子树的size信息，先判连通，判完连通之后，
x为原树根且为Splay的根，如果sz[x]==2则合法，否则不合法
inline bool cut(int x,int y){
makeroot(x);
if(findroot(y)!=x||sz[x]>2)return 0;
f[y]=c[x][1]=0;
pushup(x);
return 1;
}nroot(x)
not root的缩写，用于判断x是不是Splay的根，返回1代表不是Splay的根
f[x]的含义：
如果x不是Splay的根，f[x]=z是实边，代表x在Splay里的父亲z
如果x是Splay的根，记x所在的Splay里深度最小的点为y，f[x]=z是虚边，代表y在原树中的父亲z
ch[x][0/1]的含义：
仅用于同一棵Splay的点的左右孩子，可以认为是实边的反向边
inline bool nroot(R x){//判断节点是否为一个Splay的根（与普通Splay的区别1）
return c[f[x]][0]==x||c[f[x]][1]==x;
}//原理很简单，如果连的是轻边，他的父亲的儿子里没有它个人体会
LCT：Link-Cut Tree，动态树
像树剖分轻重链一样，动态树维护的是一个森林，森林上有虚链和实链
每个点与Splay里的点号一致，共n个点，
每个点往下只有一条链是实链，剩下全是虚链
①每个点恰好出现在一个Splay里
②一个Splay按深度关键字维护一条实链，即中序遍历这棵Splay，可以按深度增序访问这条实链
虚链的边：实际上指向的是这棵Splay里编号最小的点在原树中的父亲，只能从子找到父亲，认父不认子
实链的边：一棵Splay内部的边，既能通过f[]找父亲，也能通过ch[][0/1]找儿子
③由于Splay的根还有父亲，即虚链边对应的父亲，
所以Splay中rotate的时候，考虑x y z的时候，x的父亲是y，y的父亲是z，
z可以为虚链边的父亲，但这种情况下仍需特判，因为此时z不参与旋转，
这样，设换根之前根是x，虚链点是z，f[x]=z，则换根后设根是y，必有f[y]=z
板子整理
以洛谷P3690 动态树模板为例
#include
#define lc c[x][0]
#define rc c[x][1]
using namespace std;
const int N=3e5+9;
//f:父亲 c:儿子 v:单点值 s:子树值 stk:用于从上到下释放标记的栈 r:区间翻转标记
int n,m,f[N],c[N][2],v[N],s[N],stk[N];
bool r[N];
bool nroot(int x){//判断节点是否为一个Splay的根（与普通Splay的区别1）
return c[f[x]][0]==x||c[f[x]][1]==x;
}//原理很简单，如果连的是轻边，他的父亲的儿子里没有它
void pushup(int x){//上传信息
s[x]=s[lc]^s[rc]^v[x];
}
void pushr(int x){int t=lc;lc=rc;rc=t;r[x]^=1;}//翻转操作
void pushdown(int x){//判断并释放懒标记
if(r[x]){
if(lc)pushr(lc);
if(rc)pushr(rc);
r[x]=0;
}
}
void rotate(int x){//一次旋转
int y=f[x],z=f[y],k=c[y][1]==x,w=c[x][!k];
if(nroot(y))c[z][c[z][1]==y]=x;c[x][!k]=y;c[y][k]=w;//额外注意if(nroot(y))语句，此处不判断会引起致命错误（与普通Splay的区别2）
if(w)f[w]=y;f[y]=x;f[x]=z;
pushup(y);
}
void splay(int x){//只传了一个参数，因为所有操作的目标都是该Splay的根（与普通Splay的区别3）
int y=x,z=0;
stk[++z]=y;//st为栈，暂存当前点到根的整条路径，pushdown时一定要从上往下放标记（与普通Splay的区别4）
while(nroot(y))stk[++z]=y=f[y];
while(z)pushdown(stk[z--]);
while(nroot(x)){
y=f[x];z=f[y];
if(nroot(y))
rotate((c[y][0]==x)^(c[z][0]==y)?x:y);
rotate(x);
}
pushup(x);
}
void access(int x){//访问
for(int y=0;x;x=f[y=x]){
splay(x),rc=y,pushup(x);
}
}
void makeroot(int x){//换根
access(x);splay(x);
pushr(x);
}
int findroot(int x){//找根（在真实的树中的）
access(x);splay(x);
while(lc)pushdown(x),x=lc;
splay(x);
return x;
}
void split(int x,int y){//提取路径
makeroot(x);
access(y);splay(y);
}
void link(int x,int y){//连边
makeroot(x);
if(findroot(y)!=x)f[x]=y;
}
void cut(int x,int y){//断边
makeroot(x);
if(findroot(y)==x&&f[y]==x&&!c[y][0]){
f[y]=c[x][1]=0;
pushup(x);
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i){
scanf("%d",&v[i]);
}
while(m--){
int type,x,y;
scanf("%d%d%d",&type,&x,&y);
switch(type){
case 0:split(x,y);printf("%d\n",s[y]);break;
case 1:link(x,y);break;
case 2:cut(x,y);break;
case 3:splay(x);v[x]=y;//先把x转上去再改，不然会影响Splay信息的正确性，子树都是对的，x及以上的点会先pushup(x)
}
}
return 0;
}