Link-Cut Tree(LCT)

如果你还没有接触过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

巴特西

Link-Cut Tree(LCT)

最新文章

热门文章