LCT摘要

介绍、用途

LCT是树链剖分中的一种，又叫实链剖分、动态树，常用于维护动态的树、森林。

维护方式

LCT并不直接维护原树，而是用一堆splay作为辅助树来维护。原树中的一条实链上的点在一棵splay中，虚边体现为辅助上的连接两棵splay的虚边，只认爸爸不认儿子。

变量介绍

 int n,m;
 struct Node {
     int fa,son[];                                                                                            //爸爸、儿子（0左1右）
     int val,all;                                                                                            //该点权值、子树异或和
     char ifz;                                                                                                //是否翻转（0否1是）
     void res() {                                                                                            //重置（然并卵）
         fa=son[]=son[]=val=;
     }
 } tree[maxn];
 int pre[maxn],inp;                                                                                            //翻转序列（splay用）

var

各种操作

判断一个点是哪个儿子

不多说了

 char which(int x) {
     return x==tree[tree[x].fa].son[];
 }

which

判断一个点是不是该splay的根

也不多说了

 char isroot(int x) {
     return x!=tree[tree[x].fa].son[which(x)];
 }

isroot

splay的操作

 void rotate(int x) {
     int f=tree[x].fa,ff=tree[f].fa,c=which(x);
     if(!isroot(f)) tree[ff].son[which(f)]=x;                                                                //若它爸是根就不要搞它爷了
     tree[x].fa=ff;
     tree[f].son[c]=tree[x].son[c^];
     tree[tree[f].son[c]].fa=f;
     tree[x].son[c^]=f;
     tree[f].fa=x;
     update(f);
     update(x);
 }
 void splay(int x) {
     int f;
     pre[inp=]=x;
     for(f=x; !isroot(f); f=tree[f].fa) pre[++inp]=tree[f].fa;                                                //挖出它到根的点
     fdi(i,inp,,) pushdown(pre[i]);                                                                        //全部pushdown
     for(; !isroot(x); rotate(x))if(!isroot(tree[x].fa))rotate((which(tree[x].fa)^which(x))?x:tree[x].fa);    //无需pushdown
 }

splay

打通这个点到原树的根为实链

这个是重点！！！是LCT的核心！！！

首先，先将该节点splay到根，并将其爸爸splay到根。于是我们知道，它爸爸的右儿子深度大于它爸爸，是需要砍成虚边的点，而它的深度也大于它爸爸，所以直接将它爸爸的右儿子变成它。重复上述操作，直到它无爸爸。

 void access(int x) {
     for(int pr=; x; pr=x,x=tree[x].fa)splay(x),tree[x].son[]=pr,update(x);
 }

access

将这个点变成原树的根

先打通这个点到根，并将它splay到根。然后我们可以发现，不在这棵splay上的点不受影响，而这棵splay上的点深浅颠倒，对应到splay上就是区间翻转。所以给它打上一个翻转标记。

 void makeroot(int x) {
     access(x);
     splay(x);
     tree[x].ifz^=;                                                                                            //打翻转标记
 }

makeroot

查找这个点所在原树的根

先打通它到根并splay，然后找到它所在splay的最左边的点（即一直往左儿子找）。

 int find(int x) {
     for(access(x),splay(x); tree[x].son[]; x=tree[x].son[]);
     return x;
 }

find

连接个点并连接两棵树

将一个点变成根，并令这个点爸爸为另一个点。注意先判断这两个点在不在一棵树内，在就不用连了。

 void link(int x,int y) {
     makeroot(x);
     tree[x].fa=y;
 }

link

切断两点之间的边

先判断在不在一棵树内，不在就不切。然后将一个点变成根，另一个点打通到根并splay到根。易发现若这两个点间有边则这棵splay中只有它们俩。判断一下即可。

 void cut(int x,int y) {
     makeroot(x);
     access(y);
     splay(y);
     if(tree[y].son[]==x&&!tree[y].son[]&&!tree[x].son[]&&!tree[x].son[])tree[y].son[]=tree[x].fa=;
 }

cut

改变一个点的值

将这个点变成根，并将其splay，再改变权值即可。

 void change(int x,int y) {
     makeroot(x);
     splay(x);
     tree[x].val=y;
     update(x);
 }

change

查询x到y的异或和

将x变成根，打通y并splay，直接查询即可。

 int query(int x,int y) {
     makeroot(x);
     access(y);
     splay(y);
     return tree[y].all;
 }

query

时空复杂度

时间复杂度

splay：均摊O(logn)的不用说了吧

access：由于每次access最多有logn条实边变成虚边，splay复杂度也仅为均摊O(logn)，因此时间复杂度均摊O(logn)

makeroot：makeroot的开销主要为access，因此也为均摊O(logn)

其他：基于以上三种操作，因此都为均摊O(logn)

只是常数无比巨大！！！
只是常数无比巨大！！！
只是常数无比巨大！！！

空间复杂度

显然是O(n)的

题目

洛谷P3690 【模板】Link Cut Tree （动态树）

 #include<bits/stdc++.h>
 using namespace std;
 #define ImaxnF 0x7fffffff
 #define ME 0x7f
 #define FO(s) freopen(s".in","r",stdin);freopen(s".out","w",stdout)
 #define fui(i,a,b,c) for(int i=(a);i<=(b);i+=(c))
 #define fdi(i,a,b,c) for(int i=(a);i>=(b);i-=(c))
 #define fel(i,a) for(register int i=h[a];i;i=ne[i])
 #define ll long long
 #define MEM(a,b) memset(a,b,sizeof(a))
 #define maxn (300000+10)
 int n,m;
 struct Node{
     int fa,son[];
     int val,all;//,siz;
     char ifz;
     void res(){fa=son[]=son[]=val=/*siz=*/;}
 }tree[maxn];
 int pre[maxn],inp;
 template<class T>
 inline T read(T &n){
     n=;int t=;char ch;
     for(ch=getchar();!isdigit(ch)&&ch!='-';ch=getchar());(ch=='-')?t=-:n=ch-'';
     for(ch=getchar();isdigit(ch);ch=getchar()) n=n*+ch-'';
     return (n*=t);
 }
 template<class T>
 T write(T n){
     if(n<) putchar('-'),n=-n;
     if(n>=) write(n/);putchar(n%+'');
 }
 template<class T>
 T writeln(T n){
     write(n);putchar('\n');
 }
 char which(int x){return x==tree[tree[x].fa].son[];}
 char isroot(int x){return x!=tree[tree[x].fa].son[which(x)];}
 void update(int x){tree[x].all=tree[tree[x].son[]].all^tree[tree[x].son[]].all^tree[x].val;}
 void pushdown(int x){
     if(tree[x].ifz){
         tree[x].ifz=,swap(tree[x].son[],tree[x].son[]);
         tree[tree[x].son[]].ifz^=,tree[tree[x].son[]].ifz^=;
     }
 }void rotate(int x){
     int f=tree[x].fa,ff=tree[f].fa,c=which(x);if(!isroot(f)) tree[ff].son[which(f)]=x;
     tree[x].fa=ff;tree[f].son[c]=tree[x].son[c^];tree[tree[f].son[c]].fa=f;
     tree[x].son[c^]=f;tree[f].fa=x;update(f);update(x);
 }void splay(int x){
     int f;pre[inp=]=x;for(f=x;!isroot(f);f=tree[f].fa) pre[++inp]=tree[f].fa;fdi(i,inp,,) pushdown(pre[i]);
     for(;!isroot(x);rotate(x))if(!isroot(tree[x].fa))rotate((which(tree[x].fa)^which(x))?x:tree[x].fa);//update(x);
 }void access(int x){for(int pr=;x;pr=x,x=tree[x].fa)splay(x),tree[x].son[]=pr,update(x);}
 void makeroot(int x){access(x);splay(x);tree[x].ifz^=;}
 int find(int x){for(access(x),splay(x);tree[x].son[];x=tree[x].son[]);return x;}
 void cut(int x,int y){makeroot(x);access(y);splay(y);if(tree[y].son[]==x&&!tree[y].son[]&&!tree[x].son[]&&!tree[x].son[]/*tree[y].siz==2*/)tree[y].son[]=tree[x].fa=;}
 void link(int x,int y){makeroot(x);tree[x].fa=y;}
 void change(int x,int y){makeroot(x);splay(x);tree[x].val=y;update(x);}
 int query(int x,int y){makeroot(x);access(y);splay(y);return tree[y].all;}
 int main(){
     read(n);read(m);
     fui(i,,n,) tree[i].val=read(tree[i].all);
     fui(i,,m,){
         int opt,x,y;
         read(opt);read(x);read(y);
         switch(opt){
             case :writeln(query(x,y));break;
             case :if(find(x)!=find(y)) link(x,y);break;
             case :if(find(x)==find(y)) cut(x,y);break;
             case :change(x,y);
         }
     }
     return ;
 }

AC代码

BZOJ2049 [Sdoi2008]Cave 洞穴勘测

 #include<bits/stdc++.h>
 using namespace std;
 #define ImaxnF 0x7fffffff
 #define ME 0x7f
 #define FO(s) freopen(s".in","r",stdin);freopen(s".out","w",stdout)
 #define fui(i,a,b,c) for(int i=(a);i<=(b);i+=(c))
 #define fdi(i,a,b,c) for(int i=(a);i>=(b);i-=(c))
 #define fel(i,a) for(register int i=h[a];i;i=ne[i])
 #define ll long long
 #define MEM(a,b) memset(a,b,sizeof(a))
 #define maxn (10000+10)
 int n,m;
 struct Node{
     int fa,son[];
     char ifz;
 }tree[maxn];
 int pre[maxn],inp;
 template<class T>
 inline T read(T &n){
     n=;int t=;double x=;char ch;
     for(ch=getchar();!isdigit(ch)&&ch!='-';ch=getchar());(ch=='-')?t=-:n=ch-'';
     for(ch=getchar();isdigit(ch);ch=getchar()) n=n*+ch-'';
     if(ch=='.') for(ch=getchar();isdigit(ch);ch=getchar()) n+=(ch-'')/x,x*=;
     return (n*=t);
 }
 char which(int x){return x==tree[tree[x].fa].son[];}
 char isroot(int x){return x!=tree[tree[x].fa].son[which(x)];}
 void pushdown(int x){
     if(tree[x].ifz){
         tree[x].ifz=,swap(tree[x].son[],tree[x].son[]);
         tree[tree[x].son[]].ifz^=,tree[tree[x].son[]].ifz^=;
     }
 }
 void rotate(int x){
     int f=tree[x].fa,ff=tree[f].fa,c=which(x);if(!isroot(f)) tree[ff].son[which(f)]=x;
     tree[x].fa=ff;tree[f].son[c]=tree[x].son[c^];tree[tree[f].son[c]].fa=f;
     tree[x].son[c^]=f;tree[f].fa=x;
 }
 void splay(int x){
     int f;pre[inp=]=x;for(f=x;!isroot(f);f=tree[f].fa) pre[++inp]=tree[f].fa;fdi(i,inp,,) pushdown(pre[i]);
     for(;!isroot(x);rotate(x))if(!isroot(tree[x].fa))rotate((which(tree[x].fa)^which(x))?x:tree[x].fa);
 }
 void access(int x){for(int pr=;x;pr=x,x=tree[x].fa)splay(x),tree[x].son[]=pr;}
 void makeroot(int x){access(x);splay(x);tree[x].ifz^=;}
 int find(int x){for(access(x),splay(x);tree[x].son[];x=tree[x].son[]);return x;}
 void cut(int x,int y){makeroot(x);access(y);splay(y);if(tree[y].son[]==x&&!tree[y].son[]&&!tree[x].son[]&&!tree[x].son[])tree[y].son[]=tree[x].fa=;}
 void link(int x,int y){makeroot(x);tree[x].fa=y;}
 int main(){
     read(n);read(m);
     fui(i,,m,){
         int x,y;char opt;
         for(opt=getchar();opt!='Q'&&opt!='C'&&opt!='D';opt=getchar());read(x);read(y);
         switch(opt){
             case 'Q':puts((find(x)==find(y))?"Yes":"No");break;
             case 'C':if(find(x)!=find(y)) link(x,y);break;
             case 'D':cut(x,y);break;
         }
     }
     return ;
 }

AC代码