转载自LCT（Link-Cut Tree）详解（蒟蒻自留地）
如果你还没有接触过LCT，你可以先看一看这里：
（看不懂没关系，先留个大概的印像）http://www.cnblogs.com/BLADEVIL/p/3510997.html
看完之后我们知道，LCT和静态的树链剖分很像。怎么说呢？这两种树形结构都是由若干条长度不等的“重链”和“轻边”构成（名字可以不同，大概就是这个意思），“重链”之间由”轻边”连接。就像这样：
可以想象为一棵树被人为的砍成了一段段。
LCT和树链剖分不同的是，树链剖分的链是不会变化的，所以可以很方便的用线段树维护。但是，既然是动态树，那么树的结构形态将会发生改变，所以我们要用更加灵活的维护区间的结构来对链进行维护，不难想到Splay可以胜任。如何分离树链也是保证时间效率的关键（链的数量和长度要平衡），树链剖分的“重儿子”就体现了前人博大精深的智慧。
在这里解释一下为什么要把树砍成一条条的链：我们可以在logn的时间内维护长度为n的区间（链），所以这样可以极大的提高树上操作的时间效率。在树链剖分中，我们把一条条链放到线段树上维护。但是LCT中，由于树的形态变化，所以用能够支持合并、分离、翻转等操作的Splay维护LCT的重链（注意，单独一个节点也算是一条重链）。
这时我们注意到，LCT中的轻边信息变得无法维护。为什么呢？因为Splay只维护了重链，没有维护重链之间的轻边；而LCT中甚至连根都可以不停的变化，所以也没法用点权表示它父边的边权（父亲在变化）。所以，如果在LCT中要维护边上信息，个人认为最方便的方法应该是把边变成一个新点和两条边。这样可以把边权的信息变成点权维护，同时为了不影响，把真正的树上节点的点权变成0，就可以用维护点的方式维护边。
LCT的各种操作：
LCT中用Splay维护链，这些Splay叫做“辅助树“。辅助树以它上面每个节点的深度为关键字维护，就是辅助树中每个节点左儿子的深度小于当前节点的深度，当前节点的深度小于右儿子的深度。
可以把LCT认为是一个由Splay组成的森林，就像这样：（三角形代表一棵Splay，对应着LCT上一条链）
箭头是什么意思呢？箭头记录着某棵Splay对应的链向上由轻边连着哪个节点，可以想象为箭头指向“Splay 的父亲”。但是，Splay的父亲并不记录有这个儿子，即箭头是单向的。同时，每个节点要记录它是否是它所在的Splay的根。这样，Splay构成的森林就建成了。
这个是我的Splay节点最基本的定义：（如果要维护更多信息就像Splay维护区间那样加上更多标记）
struct Splay{ Splay *fa,*son[2];bool is_root,rev; Splay(){ memset(this,0,sizeof(Splay));is_root=1; } }
void reverse(Splay *x){//翻转x子树 if(!x)return; swap(x->son[1],x->son[0]); x->rev^=1; } void pushdown(Splay *x){//下放标记 if(x->rev){ x->rev=0; reverse(x->son[0]); reverse(x->son[1]); } } void push(Splay *x){//将x路径上的标记全部下放，为x旋到根做准备 if(!x->is_root)push(x->fa); pushdown(x); } void update(Splay *x){//更新维护的信息，因为模板中没有维护什么，所以为空 } /* 下面三个函数是普通Splay的操作 只是下放标记的方法不同 */ void rotate(Splay *&x,int d){ Splay *p=x->son[!d]; x->son[!d]=p->son[d],p->son[d]=x; p->fa=x->fa,x->fa=p; if(x->son[!d])x->son[!d]->fa=x; update(x),update(p); if(x->is_root)p->is_root=1,x->is_root=0; x=p; } void up(Splay *x){ Splay *&p=!x->fa->fa->is_root?x->fa->fa->fa->son[is_r(x->fa->fa)]:null=x->fa->fa; int d=is_r(x); if(is_r(x->fa)==d)rotate(p,!d),rotate(p,!d); else rotate(p->son[!d],!d),rotate(p,d); } void splay(Splay *x){ push(x); while(!x->is_root&&!x->fa->is_root)up(x); if(!x->is_root)rotate(null=x->fa,!is_r(x)); }
access操作：
这是LCT最核心的操作。其他所有操作都要用到它。
他的含义是”访问某节点“。作用是：对于访问的节点x，打通一条从树根（真实的LCT树）到x的重链；如果x往下是重链，那么把x往下的重边改成轻边。可以理解为专门开辟一条x到根的路径，由一棵Splay维护这条路径。
access之前：（粗的是重链） access之后：
access实现的方式很简单；
先把x旋转到所在Splay的根，然后把x的右孩子的is_root设为true（此时右孩子对应的是x下方的重链，这样就断开了x和下方的重链）。
用y记录上一次的x（初始化y=0），把y接到x的右孩子上，这样就把上一次的重链接到了当前重链一起，同时记得T[y].is_root=false。
记录y=x，然后x=T[x].fa，把x上提。重复上面的步骤直到x=0。
代码：
void access(Splay *x){ Splay *y=0; while(x){//如果x和LCT的根不在一条链上，每次将它所在的链与上面的链合并 splay(x); if(x->son[1])x->son[1]->is_root=1; if(x->son[1]=y)y->is_root=0; update(x); x=(y=x)->fa; } }
mroot操作：
这个操作的作用是把某个节点变成树根（这里的根指的是整棵LCT的根）。加上access操作，就可以方便的提取出LCT上两点之间的路径。提取u到v的路径只需要mroot(u),access(v),然后v所在的Splay对应的链就是u到v的路径。
mroot实现的方式：
由于LCT是Splay组成的森林，所以要把x变成根就只需要让所有Splay的父亲最终指向x所在Splay。所以先access(x),Splay(x)，把现在的根和将成为根的x链在一棵Splay中，并转到根即可。但是我们注意到，由于x成为了新的根，所以它和原来的根所在的Splay中深度作为关键字的性质遭到了破坏：新根x应该是Splay中深度最小的，但是之前的操作并不会改变x的深度（也就是目前x依旧是当前Splay中深度最深的）。所以，我们需要把所在的这棵Splay翻转过来。
（粗的是重链，y是原来的根）
翻转前： 翻转后：
这时候x才真正变成了根。
代码：
void mroot(Splay *x){//将x变为所在LCT的根 access(x); splay(x); reverse(x); }
link操作：
这个操作的作用是连接两棵LCT。对于link(u,v)，表示连接u所在的LCT和v所在的LCT；
link实现的方式：
很简单，只需要先mroot(u),然后记录T[u].fa=v就可以了，就是把一个Splay森林连到另一个上。
代码：
void link(Splay *u,Splay *v){//合并u和v所在的LCT mroot(u); u->fa=v; }
cut操作：
这个操作的作用是分离出两棵LCT。
代码：
void cut(Splay *u,Splay *v){ mroot(u);//将u变成根 access(v);splay(v);//v和u弄到同一条链上，并且分别为两端 pushdown(v); if(v->son[0])v->son[0]->fa=v->fa,v->son[0]->is_root=1;//将v子树和链上的点分开 v->son[0]=v->fa=0; update(v); }
这些就是LCT的基本操作。我推荐几个LCT的练习题：
bzoj2049 SDOI2008洞穴勘探
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define is_r(x) (x->fa?x->fa->son[1]==x:0)
#define maxn 10005
struct Splay{
Splay *fa,*son[2];
bool is_root,rev;
Splay(){
memset(this,0,sizeof(Splay));
}
}*root[maxn],*null=new Splay();
void reverse(Splay *x){
if(!x)return;
swap(x->son[1],x->son[0]);
x->rev^=1;
}
void pushdown(Splay *x){
if(x->rev){
x->rev=0;
reverse(x->son[0]);
reverse(x->son[1]);
}
}
void push(Splay *x){
if(!x->is_root)push(x->fa);
pushdown(x);
}
void update(Splay *x){
}
void rotate(Splay *&x,int d){
Splay *p=x->son[!d];
x->son[!d]=p->son[d],p->son[d]=x;
p->fa=x->fa,x->fa=p;
if(x->son[!d])x->son[!d]->fa=x;
update(x),update(p);
if(x->is_root)x->is_root=0,p->is_root=1;
x=p;
}
void up(Splay *x){
Splay *&p=!x->fa->fa->is_root?(x->fa->fa->fa->son[is_r(x->fa->fa)]):null=x->fa->fa;
int d=is_r(x);
if(is_r(x->fa)==d)rotate(p,!d),rotate(p,!d);
else rotate(p->son[!d],!d),rotate(p,d);
}
void splay(Splay *x){
push(x);
while(!x->is_root&&!x->fa->is_root)up(x);
if(!x->is_root)rotate(null=x->fa,!is_r(x));
}
void access(Splay *x){
Splay *y=NULL;
while(x){
splay(x);
if(x->son[1])x->son[1]->is_root=1;
x->son[1]=y;
if(y)y->is_root=0;
update(x);
x=(y=x)->fa;
}
}
void mroot(Splay *x){
access(x);
splay(x);
reverse(x);
}
void link(Splay *u,Splay *v){
mroot(u);u->fa=v;
}
void cut(Splay *u,Splay *v){
mroot(u);
splay(v);
pushdown(v);
if(v->son[0])v->son[0]->fa=v->fa,v->son[0]->is_root=1;
v->son[0]=v->fa=0;
}
bool judge(Splay *u,Splay *v){
while(u->fa)u=u->fa;
while(v->fa)v=v->fa;
return u==v;
}
int main(){
int n,m,u,v;scanf("%d%d",&n,&m);
char op[10];
for(int i=1;i<=n;i++){
root[i]=new Splay();root[i]->is_root=1;
}
for(int i=0;i<m;i++){
scanf("%s%d%d",op,&u,&v);
if(op[0]=='C'){
link(root[u],root[v]);
}
else if(op[0]=='D'){
cut(root[u],root[v]);
}
else{
if(judge(root[u],root[v]))printf("Yes
");
else printf("No
");
}
}
return 0;
}
模板题，只需要link和cut，然后询问连通性。题解：
http://blog.csdn.net/saramanda/article/details/55210235
bzoj2002 HNOI2010弹飞绵羊
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 200005
#define size(x) (x?x->size:0)
#define is_r(x) (x->fa?x->fa->son[1]==x:0)
struct Splay{
Splay *fa,*son[2];
int size;
bool is_root;
Splay(){
memset(this,0,sizeof(Splay));
is_root=size=1;
}
}*root[maxn],*null=new Splay();
void update(Splay *x){
x->size=size(x->son[0])+size(x->son[1])+1;
}
void rotate(Splay *&x,int d){
Splay *p=x->son[!d];
x->son[!d]=p->son[d],p->son[d]=x;
p->fa=x->fa,x->fa=p;
if(x->son[!d])x->son[!d]->fa=x;
if(x->is_root)x->is_root=0,p->is_root=1;
update(x),update(p);
x=p;
}
void up(Splay *x){
Splay *&p=(!x->fa->fa->is_root)?x->fa->fa->fa->son[is_r(x->fa->fa)]:null=x->fa->fa;
int d=is_r(x);
if(is_r(x->fa)==d)rotate(p,!d),rotate(p,!d);
else rotate(p->son[!d],!d),rotate(p,d);
}
void splay(Splay *x){
// push(x);
while(!x->is_root&&!x->fa->is_root)up(x);
if(!x->is_root)rotate(null=x->fa,!is_r(x));
}
void access(Splay *x){
Splay *y=0;
while(x){
splay(x);
if(x->son[1])x->son[1]->is_root=1;
if(x->son[1]=y)y->is_root=0;
update(x);
x=(y=x)->fa;
}
}
void link(Splay *u,Splay *v){//这里把cut操作也合并到link里了
access(u);splay(u);
if(u->son[0])u->son[0]->is_root=1,u->son[0]->fa=0;
u->son[0]=0,u->fa=v;
update(u);
}
int main(){
int n,m,op,u,v;
scanf("%d",&n);
for(int i=0;i<n+1;i++)root[i]=new Splay();
for(int i=0;i<n;i++){
scanf("%d",&u);
if(i+u>n)u=n-i;
link(root[i],root[i+u]);
}
scanf("%d",&m);
for(int i=0;i<m;i++){
scanf("%d",&op);
if(op==1){
scanf("%d",&u);
access(root[u]);splay(root[u]);
printf("%d
",root[u]->son[0]->size);
}
else{
scanf("%d%d",&u,&v);
if(u+v>n)v=n-u;
link(root[u],root[u+v]);
}
}
return 0;
}
模板题，需要link和询问某点到根的路径长度。题解：
http://blog.csdn.net/saramanda/article/details/55210418
bzoj3669 NOI2014魔法森林
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define maxn 50005
#define is_r(x) (x->fa?x->fa->son[1]==x:0)
struct Splay{
Splay *fa,*son[2],*ma1;
int ma,x;
bool is_root,rev;
Splay(){
memset(this,0,sizeof(Splay));is_root=1;
}
}*null,*root[maxn*3];
struct Edge{
int a,b,u,v;
bool operator < (const Edge &c)const{
return a<c.a;
}
}edge[maxn<<1];
void reverse(Splay *x){
if(!x)return;
swap(x->son[1],x->son[0]);
x->rev^=1;
}
void pushdown(Splay *x){
if(x->rev){
x->rev=0;
reverse(x->son[0]);
reverse(x->son[1]);
}
}
void push(Splay *x){
if(!x->is_root)push(x->fa);
pushdown(x);
}
void update(Splay *x){
x->ma1=x,x->ma=x->x;
if(x->son[0]&&x->son[0]->ma>x->ma)x->ma1=x->son[0]->ma1,x->ma=x->son[0]->ma;
if(x->son[1]&&x->son[1]->ma>x->ma)x->ma1=x->son[1]->ma1,x->ma=x->son[1]->ma;
}
void rotate(Splay *&x,int d){
Splay *p=x->son[!d];
x->son[!d]=p->son[d],p->son[d]=x;
p->fa=x->fa,x->fa=p;
if(x->son[!d])x->son[!d]->fa=x;
update(x),update(p);
if(x->is_root)p->is_root=1,x->is_root=0;
x=p;
}
void up(Splay *x){
Splay *&p=!x->fa->fa->is_root?x->fa->fa->fa->son[is_r(x->fa->fa)]:null=x->fa->fa;
int d=is_r(x);
if(is_r(x->fa)==d)rotate(p,!d),rotate(p,!d);
else rotate(p->son[!d],!d),rotate(p,d);
}
void splay(Splay *x){
push(x);
while(!x->is_root&&!x->fa->is_root)up(x);
if(!x->is_root)rotate(null=x->fa,!is_r(x));
}
void access(Splay *x){
Splay *y=0;
while(x){
splay(x);
if(x->son[1])x->son[1]->is_root=1;
if(x->son[1]=y)y->is_root=0;
update(x);
x=(y=x)->fa;
}
}
void mroot(Splay *x){
access(x);
splay(x);
reverse(x);
}
void link(Splay *u,Splay *v){
mroot(u);
u->fa=v;
}
void cut(Splay *u,Splay *v){
mroot(u),access(v),splay(v);
pushdown(v);
if(v->son[0])v->son[0]->fa=v->fa,v->son[0]->is_root=1;
v->son[0]=v->fa=0;
update(v);
}
int fa[maxn];
int Find(int x){
return fa[x]==x?x:fa[x]=Find(fa[x]);
}
int main(){
int n,m,now;scanf("%d%d",&n,&m),now=n;
for(int i=1;i<=n;i++){
root[i]=new Splay();
fa[i]=i;
}
for(int i=0;i<m;i++){
scanf("%d%d%d%d",&edge[i].u,&edge[i].v,&edge[i].a,&edge[i].b);
}
sort(edge,edge+m);
int u,v,a,b,ans=0x3fffffff;Splay *x;
for(int i=0;i<m;i++){
u=edge[i].u,v=edge[i].v;
if((a=Find(u))==(b=Find(v))){
mroot(root[u]);access(root[v]);splay(root[v]);
x=root[v]->ma1;
if(x->ma>edge[i].b){
root[++now]=new Splay();
root[now]->ma=root[now]->x=edge[i].b;
cut(root[u],x),cut(root[v],x);
link(root[v],root[now]);link(root[u],root[now]);
}
}
else{
root[++now]=new Splay();
root[now]->ma=root[now]->x=edge[i].b;
link(root[now],root[u]);link(root[now],root[v]);
fa[a]=b;
}
if(Find(1)==Find(n)){
mroot(root[1]);
access(root[n]);splay(root[n]);
ans=min(ans,root[n]->ma+edge[i].a);
}
}
printf("%d",ans==0x3fffffff?-1:ans);
return 0;
}
LCT的综合应用。题解：