Link-Cut Tree(LCT)

转载自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[];bool is_root,rev;
    Splay(){
        memset(this,,sizeof(Splay));is_root=;
    }
}

LCT中基本的Splay上操作：

void reverse(Splay *x){//翻转x子树
    if(!x)return;
    swap(x->son[],x->son[]);
    x->rev^=;
}
void pushdown(Splay *x){//下放标记
    if(x->rev){
        x->rev=;
        reverse(x->son[]);
        reverse(x->son[]);
    }
}
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=,x->is_root=;
    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=;
    while(x){//如果x和LCT的根不在一条链上，每次将它所在的链与上面的链合并
        splay(x);
        if(x->son[])x->son[]->is_root=;
        if(x->son[]=y)y->is_root=;
        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[])v->son[]->fa=v->fa,v->son[]->is_root=;//将v子树和链上的点分开
    v->son[]=v->fa=;
    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\n");
			else printf("No\n");
		}
	}
	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\n",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的综合应用。题解：

http://blog.csdn.net/saramanda/article/details/55250852