动态树 Link-Cut Trees

动态树

动态树问题, 即要求我们维护一个由若干棵子结点无序的有根树组成的森林。

要求这个数据结构支持对树的分割、合并，对某个点到它的根的路径的某些操作，以及对某个点的子树进行的某些操作。

在这里我们考虑一个简化的动态树问题，它只包含对树的形态的操作和对某个点到根的路径的操作：

维护一个数据结构，支持以下操作:

• MAKE TREE() — 新建一棵只有一个结点的树。

• CUT(v) — 删除 v 与它的父亲结点 parent(v) 的边，相当于将点 v 的子树分离了出来。

• JOIN(v,w) — 让 v 成为 w 的新的儿子。其中 v 是一棵树的根结点，并且 v 和 w 是不同的两棵树中的结点。

• FIND ROOT(v) — 返回 v 所在的树的根结点。搞清了这个问题，我们也容易扩充这个数据结构，维护每个点到它所属的树的根结点的路径的一些信息，例如权和、边权的最大值、路径长度等。

Link-Cut Trees

Link-Cut Trees 是由 Sleator 和 Tarjan 发明的解决这类动态树问题的一种数据结构。

这个数据结构可以在均摊 O(logn) 的时间内实现上述动态树问题的每个操作。

如果没有用对树的形态的改变的话，我们可以用树链剖分，把树剖分成许多条链并维护上面的权值信息。

然而对于树的形态的改变，树链的剖分方案也要改变，我们借助 Splay 的思想来动态维护许多树链（称为 Link-Cut Trees）。

Link-Cut Trees 的定义

称一个点被访问过，如果刚刚执行了对这个点的 ACCESS 操作。如果结点 v 的子树中，最后被访问的结点在子树 w 中，这里 w 是 v 的儿子, 那么就称 w 是 v 的 Preferred Child。如果最后被访问过的结点就是 v 本身，那么它没有 Preferred Child。每个点到它的 Preferred Child 的边称作 Preferred Edge。由 Preferred Edge 连接成的不可再延伸的路径称为 Preferred Path。这样，整棵树就被划分成了若干条 Preferred Path。对每条 Preferred Path，用这条路上的点的深度作为关键字，用一棵平衡树来维护它(在这棵平衡树中，每个点的左子树中的点，都在 Preferred Path 中这个点的上方；右子树中的点，都在 Preferred Path 中这个点的下方)。需要注意的是，这种平衡树必须支持分离与 合并。这里，我们选择 Splay Tree 作为这个平衡树的数据结构。我们把这棵平衡树称为一棵 Auxiliary Tree。知道了树 T 分解成的这若干条 Preferred Path，我们只需要再知道这些路径之间的连接关系，就可以表示出这棵树 T。用 Path Parent 来记录每棵 Auxiliary Tree 对应的 Preferred Path 中的最高点的父亲结点，如果这个 Preferred Path 的最高点就是根结点，那么令这棵 Auxiliary Tree 的 Path Parent 为 null。Link-Cut Trees 就是将要维护的森林中的每棵树 T 表示为若干个 Auxiliary Tree。并通过 Path Parent 将这些 Auxiliary Tree 连接起来的数据结构。

实际上，对于定义要从两方面去理解：

首先是逻辑结构，存在着一棵或多棵树，这是在逻辑上存在的，我们要做的就是对这个森林进行操作与维护；

其次是物理结构，我们并没有直接储存这些树，而是把树剖分成了多条链，每条链作为一棵 Splay。Splay 中的最小结点就是链的头结点。

回顾一下定义：

ACCESS(访问)：又叫 Expose，对结点的访问操作。

Preferred Child(最佳孩子)：最近一次访问过的儿子。最近一次被访问过的结点没有 Preferred Child。

Preferred Edge(最佳边)：每个结点到 Preferred Child 的边。

Preferred Path(最佳路径)：连续的 Preferred Edge 组成的边。

Auxiliary Tree(辅助树)：在 Splay 上维护一条链，对于 Splay 上的每个结点，它的左子树上的点都在链的上方，右子树的点都在链的下方。

Path Parent(路径的父亲)：记录链上最高结点的父亲，也就是 Splay 最左边结点的父亲，用于表示链与链之间的关系。

Link-Cut Trees 的操作

Access

ACCESS 操作是 Link-Cut Trees 的所有操作的基础。假设调用了过程 ACCESS(v)，那么从点 v 到根结点的路径就成为一条新的 Preferred Path。如果路径上经过的某个结点 u 并不是它的父亲 parent(u) 的 Preferred Child，那么由于 parent(u) 的 Preferred Child 会变为 u，原本包含 parent(u) 的 Preferred Path 将不再包含结点 parent(u) 及其之上的部分。

也就是说，过程 ACCESS 会改变逻辑上的树上的链剖分，它将结点 v 到根结点的路径作为一条新的链。而这条链会把旧的链切割开。

在物理上的 Splay 的表现就是，Splay 中的一些树被断开与重组。

下图为 Link-Cut Trees 的一个结构示意图，及一次 ACCESS 操作的前后对比图。

首先，由于访问了点 v，那么它的 Preferred Child 应当消失。先将点 v 旋转到它所属的 Auxiliary Tree 的根，如果 v 在 v 所属的 Auxiliary Tree 中有右儿子(也就是 v 原来的 Preferred Child), 那么应该将 v 在 v 所属的 Auxiliary Tree 中的右子树(对应着它的原来的 Preferred Child 之下的 Preferred Path)从 v 所属的 Auxiliary Tree 中分离，并设置这个新的 Auxiliary Tree 的 Path Parent 为 v。然后，如果点 v 所属的 Preferred Path 并不包含根结点，设它的 Path Parent 为 u，那么需要将 u 旋转 到 u 所属的 Auxiliary Tree 的根，并用点 v 所属的 Auxiliary Tree 替换到点 u 所属的 Auxiliary Tree 中 点 u 的右子树，再将原来点 u 所属的 Auxiliary Tree 中点 u 的右子树的 Path Parent 设置为 u。如此操作，直到到达包含根结点的 Preferred Path。

这里说的是对 Splay 的具体操作，对于访问的结点 v，伸展它到根，这样左子树的点在链的上方，右子树的点在链的下方。断开右子树即断开 v 在原树上与下方链的连接。

之后在 Splay 上将链的父结点 u 伸展到根，用 v 替换 u 的右子树，表现在逻辑树上就是将 u 下方的旧链替换成我们新的链。

在具体实现的时候，Splay 上的父亲与 Path Parent 可以在同一个数组上存储，当一个结点是它父结点的某个儿子时，它的父结点是 Splay 上的父结点，否则是 Path Parent。

Find Root

在 ACCESS(v) 之后，根结点一定是 v 所属的 Auxiliary Tree 的最小结点，我们先把 v 旋转到它所属 的 Auxiliary Tree 的根。再从 v 开始, 沿着 Auxiliary Tree 向左走，直到不能再向左，这个点就是我们要找的根结点。由于使用的是 Splay Tree 数据结构保存 Auxiliary Tree，我们还需要对根结点进行 Splay 操作。

在访问过 v 之后，v 与树的根就在同一个链上了，在 Splay 中就是属于同一棵平衡树。这样 v 所在的平衡树的最左结点就是链的头结点即根结点。

对根结点伸展是为了保证 Splay 的平衡。其实不做也没关系？

Cut

先访问 v，然后把 v 旋转到它所属的 Auxiliary Tree 的根，然后再断开 v 在它的所属 Auxiliary Tree 中 与它的左子树的连接，并设置。

显然，v 到根的路径属于同一条链，保存在 Splay 上的同一棵平衡树中，此时 v 为平衡树的根，左子树在链的上方，右子树在链的下方，断开左子树就是断开逻辑树上的父边。

Join

先访问 v，然后修改 v 所属的 Auxiliary Tree 的 Path Parent 为 w，然后再次访问 v。

实际上似乎有一种方法可以直接合并两棵无根树？具体写法见模板。

大致思路是，对于要连接的两点 v、w，先访问 v，再访问 w，之后伸展 v 到根，此时 v 只有左子树没有右子树，因为 v 是剖分出的链的最底端，然后给 v 打一个延迟翻转标记，设他的父亲为 w。之后在每次伸展操作之前，找到要伸展的点的所有的父结点，然后从上到下维护翻转操作。

这样做的原理是，访问 v 剖分出 v 到根的路径，然后将这个路径翻转，也就是树的其它结构不变，而这个把 v 提升到路径的最顶端，而原来的根成为了路径的最底短。

算法模板

SPOJ OTOCI

3种操作，将不属于同一棵树的两点间建一条边，查询两点路径上的点权和，修改某点的权值。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 using namespace std;

 const int MaxNode=;

 int Lch[MaxNode];
 int Rch[MaxNode];
 int Pnt[MaxNode];
 int Data[MaxNode];
 int Sum[MaxNode];
 int Rev[MaxNode];
 int List[MaxNode];
 int Total;

 inline bool isRoot(int t){
     return (!Pnt[t]||(Lch[Pnt[t]]!=t&&Rch[Pnt[t]]!=t));
 }
 inline void Update(int cur){
     Sum[cur]=Sum[Lch[cur]]+Sum[Rch[cur]]+Data[cur];
 }
 void Reverse(int cur){
     if (!Rev[cur]) return;
     swap(Lch[cur],Rch[cur]);
     Rev[Lch[cur]]^=;
     Rev[Rch[cur]]^=;
     Rev[cur]=;
 }
 void LeftRotate(int cur){
     if (isRoot(cur)) return;
     int pnt=Pnt[cur],anc=Pnt[pnt];
     Lch[pnt]=Rch[cur];
     if (Rch[cur]) Pnt[Rch[cur]]=pnt;
     Rch[cur]=pnt;
     Pnt[pnt]=cur;
     Pnt[cur]=anc;
     if (anc){
         if (Lch[anc]==pnt) Lch[anc]=cur;
         else if (Rch[anc]==pnt) Rch[anc]=cur;
     }
     Update(pnt);
     Update(cur);
 }
 void RightRotate(int cur){
     if (isRoot(cur)) return;
     int pnt=Pnt[cur],anc=Pnt[pnt];
     Rch[pnt]=Lch[cur];
     if (Lch[cur]) Pnt[Lch[cur]]=pnt;
     Lch[cur]=pnt;
     Pnt[pnt]=cur;
     Pnt[cur]=anc;
     if (anc){
         if (Rch[anc]==pnt) Rch[anc]=cur;
         else if (Lch[anc]==pnt) Lch[anc]=cur;
     }
     Update(pnt);
     Update(cur);
 }
 void Splay(int cur){
     int pnt,anc;
     List[++Total]=cur;
     for (int i=cur;!isRoot(i);i=Pnt[i]) List[++Total]=Pnt[i];
     for (;Total;--Total)
         if (Rev[List[Total]]) Reverse(List[Total]);
     while (!isRoot(cur)){
         pnt=Pnt[cur];
         if (isRoot(pnt)){// 父亲是根结点，做一次旋转
             if (Lch[pnt]==cur) LeftRotate(cur);
             else RightRotate(cur);
         }
         else{
             anc=Pnt[pnt];
             if (Lch[anc]==pnt){
                 if (Lch[pnt]==cur) LeftRotate(pnt),LeftRotate(cur);// 一条线
                 else RightRotate(cur),LeftRotate(cur);// 相反两次
             }
             else{
                 if (Rch[pnt]==cur) RightRotate(pnt),RightRotate(cur);// 一条线
                 else LeftRotate(cur),RightRotate(cur);// 相反两次
             }
         }
     }
 }
 int Expose(int u){
     int v=;
     for (;u;u=Pnt[u]) Splay(u),Rch[u]=v,v=u,Update(u);
     for (;Lch[v];v=Lch[v]);
     return v;
 }
 void Modify(int x,int d){
     Splay(x);
     Data[x]=d;
     Update(x);
 }
 int Query(int x,int y){
     int rx=Expose(x),ry=Expose(y);
     if (rx==ry){
         for (int u=x,v=;u;u=Pnt[u]){
             Splay(u);
             if (!Pnt[u]) return Sum[Rch[u]]+Data[u]+Sum[v];
             Rch[u]=v;
             Update(u);
             v=u;
         }
     }
     return -;
 }
 bool Join(int x,int y){
     int rx=Expose(x),ry=Expose(y);
     if (rx==ry) return false;
     else{
         Splay(x);
         Rch[x]=;
         Rev[x]=;
         Pnt[x]=y;
         Update(x);
         return true;
     }
 }
 void Cut(int x){
     if (Pnt[x]){
         Expose(x);
         Pnt[Lch[x]]=;
         Lch[x]=;
         Update(x);
     }
 }
 int n,Q;

 void init(){
     Total=;
     memset(Rev,,sizeof(Rev));
     memset(Pnt,,sizeof(Pnt));
     memset(Lch,,sizeof(Lch));
     memset(Rch,,sizeof(Rch));
     memset(Sum,,sizeof(Sum));
 }
 char cmd[];
 int main()
 {
     init();
     scanf("%d",&n);
     for (int i=;i<=n;i++) scanf("%d",&Data[i]);
     scanf("%d",&Q);
     while (Q--){
         int x,y;
         scanf("%s%d%d",cmd,&x,&y);
         if (cmd[]=='p'){
             Modify(x,y);
         }
         if (cmd[]=='b'){
             if (Join(x,y)) printf("yes\n");
             else printf("no\n");
         }
         if (cmd[]=='e'){
             int ans=Query(x,y);
             if (ans==-) printf("impossible\n");
             else printf("%d\n",ans);
         }
     }
     return ;
 }

SPOJ OTOCI

SPOJ QTREE

一棵树，两种操作，询问路径上的边权最大值，修改边权。

由于LCT常数太大，我实在是搞不定这题。

kuangbin巨巨的代码能卡着过去，在这里贴一下。

http://www.cnblogs.com/kuangbin/p/3300217.html

 /* ***********************************************
 Author        :kuangbin
 Created Time  :2013-9-3 21:06:05
 File Name     :F:\2013ACM练习\专题学习\动态树-LCT\SPOJQTREE.cpp
 ************************************************ */

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <set>
 #include <map>
 #include <string>
 #include <math.h>
 #include <stdlib.h>
 #include <time.h>
 using namespace std;

 //对一颗树，进行两个操作：
 //1.修改边权
 //2.查询u->v路径上边权的最大值
 const int MAXN = ;
 int ch[MAXN][],pre[MAXN];
 int Max[MAXN],key[MAXN];
 bool rt[MAXN];
 void push_down(int r)
 {

 }
 void push_up(int r)
 {
     Max[r] = max(max(Max[ch[r][]],Max[ch[r][]]),key[r]);
 }
 void Rotate(int x)
 {
     int y = pre[x], kind = ch[y][]==x;
     ch[y][kind] = ch[x][!kind];
     pre[ch[y][kind]] = y;
     pre[x] = pre[y];
     pre[y] = x;
     ch[x][!kind] = y;
     if(rt[y])
         rt[y] = false, rt[x] = true;
     else
         ch[pre[x]][ch[pre[x]][]==y] = x;
     push_up(y);
 }
 void P(int r)
 {
     if(!rt[r])P(pre[r]);
     push_down(r);
 }
 void Splay(int r)
 {
     //P(r);
     while( !rt[r] )
     {
         int f = pre[r], ff = pre[f];
         if(rt[f])
             Rotate(r);
         else if( (ch[ff][]==f)==(ch[f][]==r) )
             Rotate(f), Rotate(r);
         else
             Rotate(r), Rotate(r);
     }
     push_up(r);
 }
 int Access(int x)
 {
     int y = ;
     do
     {
         Splay(x);
         rt[ch[x][]] = true, rt[ch[x][]=y] = false;
         push_up(x);
         x = pre[y=x];
     }
     while(x);
     return y;
 }
 //调用后u是原来u和v的lca,v和ch[u][1]分别存着lca的2个儿子
 //(原来u和v所在的2颗子树)
 void lca(int &u,int &v)
 {
     Access(v), v = ;
     while(u)
     {
         Splay(u);
         if(!pre[u])return;
         rt[ch[u][]] = true;
         rt[ch[u][]=v] = false;
         push_up(u);
         u = pre[v = u];
     }
 }

 void change(int u,int k)
 {
     Access(u);
     key[u] = k;
     push_up(u);
 }
 void query(int u,int v)
 {
     lca(u,v);
     printf("%d\n",max(Max[v],Max[ch[u][]]));
 }

 struct Edge
 {
     int to,next;
     int val;
     int index;
 }edge[MAXN*];
 int head[MAXN],tot;
 int id[MAXN];

 void addedge(int u,int v,int val,int index)
 {
     edge[tot].to = v;
     edge[tot].next = head[u];
     edge[tot].val = val;
     edge[tot].index = index;
     head[u] = tot++;
 }
 void dfs(int u)
 {
     for(int i = head[u];i != -;i = edge[i].next)
     {
         int v = edge[i].to;
         if(pre[v] != )continue;
         pre[v] = u;
         id[edge[i].index] = v;
         key[v] = edge[i].val;
         dfs(v);
     }
 }
 void init()
 {
     tot = ;
     memset(head,-,sizeof(head));
 }
 int main()
 {
     //freopen("in.txt","r",stdin);
     //freopen("out.txt","w",stdout);
     int T;
     int n;
     int u,v,w;
     char op[];
     scanf("%d",&T);
     while(T--)
     {
         init();
         scanf("%d",&n);
         for(int i = ;i <= n;i++)
         {
             pre[i] = ;
             ch[i][] = ch[i][] = ;
             rt[i] = true;
         }
         Max[] = -;
         for(int i = ;i < n;i++)
         {
             scanf("%d%d%d",&u,&v,&w);
             addedge(u,v,w,i);
             addedge(v,u,w,i);
         }
         pre[] = -;
         dfs();
         pre[] = ;
         while(scanf("%s",&op) == )
         {
             if(op[] == 'D')break;
             scanf("%d%d",&u,&v);
             if(op[] == 'C')
                 change(id[u],v);
             else query(u,v);
         }
     }
     return ;
 }

kuangbin巨巨的动态树