动态树是一类要求维护森林的连通性的题的总称,
这类问题要求维护某个点到根的某些数据,支持树的切分,合并,
以及对子树的某些操作
其中解决这一问题的某些简化版(不包括对子树的操作)的基础数据结构
就是LCT(link-cut tree)
定义:
首先来定义一些量:
access(x)(或者叫expose(x)):表示访问X点
Preferred child(偏爱子节点):如果最后被访问的点在X的儿子P节点的子树中,那么称P为X的Preferred child,如果一个点被访问,他的Preferred child为null(即没有)。
Preferred edge(偏爱边):每个点到自己的Preferred child的边被称为Preferred edge。
Preferred path(偏爱路径):由Preferred edge组成的不可延伸的路径称为Preferred path。
这样我们可以发现一些比较显然的性质,
每个点在且仅在一条Preferred path上,
也就是所有的Preferred path包含了这棵树上的所有的点,
这样一颗树就可以由一些Preferred path来表示(类似于轻重链剖分中的重链),
我们用splay来维护每个条Preferred path,关键字为深度,
也就是每棵splay中的点左子树的深度都比当前点小,右节点的深度都比当前节点的深度大
这样的每棵splay我们称为Auxiliary tree(辅助树),
每个Auxiliary tree的根节点保存这个Auxiliary tree与上一棵Auxiliary tree中的哪个点相连
这个点称作他的Path parent(路上祖先)
操作:
expose(x):首先由于preferred path的定义,如果一个点被访问,
那么这个点到根节点的所有的边都会变成preferred edge,
由于每个点只有一个preferred child,所以这个点到根节点路径上的所有的点都会和原来的preferred child断开,
连接到这条新的preferred path上
假设访问x点,那么先将x点旋转到对应Auxiliary tree的根节点,
因为被访问的点是没有preferred child的,所以将Auxiliary tree中根节点(x)与右子树的边断掉,
左节点保留,将这个树的path parent旋转到对应Auxiliary tree的根节点,
断掉右子树,连接这个点与x点,相当于合并两棵Auxiliary tree,
不断地重复这一操作,直到当前X所在Auxiliary tree的path parent为null时停止,表示已经完成当前操作
find root(x):找到某一点所在树的根节点(维护森林时使用)
只需要expose(X),然后将X节点旋到对应Auxiliary tree的根节点,
然后找到这个Auxiliary tree中最左面的点
cut(x):断掉X节点和其父节点相连的边
首先expose(x),将x旋转到对应Auxiliary tree的根节点,
然后断掉Auxiliary tree中x和左节点相连的边
link(x,y):连接点x到y点上,即让x成为y的子节点
因为x为y的子节点后,
在原x的子树中,x点到根节点的所有的点的深度会被翻转过来,
所以先expose(x),然后在对应的Auxiliary tree中将x旋转到根节点,
然后将子树翻转(splay中的reverse操作),
然后expose(y),将y旋转到对应Auxiliary tree中的根节点,将x连到y就行了。
时间复杂度:
证明expose以及其他操作的时间复杂度是均摊log2N的,
具体证明参考杨哲的论文《QTREE 解法的一些研究》。
#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int N=1000005;
int n,m,root,cnt;
int size[N],mx[N],pre[N],v[N],ch[N][2],q[N];
bool rev[N];
struct node{
int x,y,nxt;
};
node way[N<<1];
int st[N],tot=0;
int get(int x)
{
return ch[pre[x]][0]==x ? 0:1;
//x是爸爸哪个孩子
}
int isroot(int x)
{
return ch[pre[x]][0]!=x&&ch[pre[x]][1]!=x;
//判断该节点是不是根
}
void update(int x) //这里我维护的是子树大小
{
size[x]=1;
if (ch[x][0]) size[x]+=size[ch[x][0]];
if (ch[x][1]) size[x]+=size[ch[x][1]];
}
void push(int x) //一般是用来处理翻转操作的
{
if (x&&rev[x])
{
rev[x]^=1;
if (ch[x][0]) rev[ch[x][0]]^=1;
if (ch[x][1]) rev[ch[x][1]]^=1;
swap(ch[x][0],ch[x][1]);
}
}
void rotate(int x)
{
int fa=pre[x];
int grand=pre[fa];
int wh=get(x);
if (!isroot(fa)) ch[grand][ch[grand][0]==fa? 0:1]=x;
//爸爸不是根,那么一定有爷爷
ch[fa][wh]=ch[x][wh^1]; //爸爸和儿子的关系一定对应好
pre[ch[fa][wh]]=fa;
pre[x]=grand; pre[fa]=x;
ch[x][wh^1]=fa;
update(fa);
update(x);
}
void splay(int x)
{
int top=0;
q[++top]=x;
for (int i=x;!isroot(i);i=pre[i]) //把该节点到根的所有节点入队
q[++top]=pre[i]; //pre[i]
while (top) push(q[top--]); //全部push
for (int fa;!isroot(x);rotate(x))
if (!isroot(fa=pre[x]))
rotate(get(fa)==get(x)? fa:x);
}
void expose(int bh)
{
int t=0;
while (bh)
{
splay(bh);
ch[bh][1]=t; //expose后节点的右儿子就没了
update(bh); //产生了一个新儿子,所以需要update
t=bh;
bh=pre[bh];
}
}
void makeroot(int bh)
{
expose(bh);
splay(bh);
rev[bh]^=1; //把x换到根上,那么ta以上的节点深度互换
}
void link(int x,int y)
{
makeroot(x);
pre[x]=y; //x转到根上之后链接,这样牵扯到的节点较少
}
void cut(int x,int y)
{
makeroot(x);
expose(y);
splay(y);
ch[y][0]=pre[x]=0;
}
int find(int bh)
{
expose(bh);
splay(bh);
while (ch[bh][0]) bh=ch[bh][0]; //找到根节点
return bh;
}
int main()
{
//两点连通性
if (find(x)==find(y)) printf("Yes\n");
//两点距离
makeroot(x);
expose(y);
splay(y);
printf("%d\n",size[ch[y][0]]);
//路径上的节点权值和
makeroot(x);
expose(y);
splay(y);
printf("%d\n",sum[y]);
//节点到根的距离
int ro=find(x);
makeroot(ro);
expose(x);
splay(x);
printf("%d\n",size[ch[x][0]]);
//更改节点值
makeroot(x);
v[x]=z;
update(x);
}