动态树问题, 即要求我们维护一个由若干棵子结点无序的有根树组成的森林。
要求这个数据结构支持对树的分割、合并,对某个点到它的根的路径的某些操作,以及对某个点的子树进行的某些操作。
在这里我们考虑一个简化的动态树问题,它只包含对树的形态的操作和对某个点到根的路径的操作:
维护一个数据结构,支持以下操作:
• MAKE TREE() — 新建一棵只有一个结点的树。
• CUT(v) — 删除 v 与它的父亲结点 parent(v) 的边,相当于将点 v 的子树分离了出来。
• JOIN(v,w) — 让 v 成为 w 的新的儿子。其中 v 是一棵树的根结点,并且 v 和 w 是不同的两棵树中的结点。
• FIND ROOT(v) — 返回 v 所在的树的根结点。搞清了这个问题,我们也容易扩充这个数据结构,维护每个点到它所属的树的根结点的路径的一些信息,例如权和、边权的最大值、路径长度等。
Link-Cut Trees 是由 Sleator 和 Tarjan 发明的解决这类动态树问题的一种数据结构。
这个数据结构可以在均摊 O(logn) 的时间内实现上述动态树问题的每个操作。
如果没有用对树的形态的改变的话,我们可以用树链剖分,把树剖分成许多条链并维护上面的权值信息。
然而对于树的形态的改变,树链的剖分方案也要改变,我们借助 Splay 的思想来动态维护许多树链(称为 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 最左边结点的父亲,用于表示链与链之间的关系。
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。
在 ACCESS(v) 之后,根结点一定是 v 所属的 Auxiliary Tree 的最小结点,我们先把 v 旋转到它所属 的 Auxiliary Tree 的根。再从 v 开始, 沿着 Auxiliary Tree 向左走,直到不能再向左,这个点就是我们要找的根结点。由于使用的是 Splay Tree 数据结构保存 Auxiliary Tree,我们还需要对根结点进行 Splay 操作。
在访问过 v 之后,v 与树的根就在同一个链上了,在 Splay 中就是属于同一棵平衡树。这样 v 所在的平衡树的最左结点就是链的头结点即根结点。
对根结点伸展是为了保证 Splay 的平衡。其实不做也没关系?
先访问 v,然后把 v 旋转到它所属的 Auxiliary Tree 的根,然后再断开 v 在它的所属 Auxiliary Tree 中 与它的左子树的连接,并设置。
显然,v 到根的路径属于同一条链,保存在 Splay 上的同一棵平衡树中,此时 v 为平衡树的根,左子树在链的上方,右子树在链的下方,断开左子树就是断开逻辑树上的父边。
先访问 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=31000; 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]]^=1; Rev[Rch[cur]]^=1; Rev[cur]=0; } 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=0; 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=0;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 -1; } bool Join(int x,int y){ int rx=Expose(x),ry=Expose(y); if (rx==ry) return false; else{ Splay(x); Rch[x]=0; Rev[x]=1; Pnt[x]=y; Update(x); return true; } } void Cut(int x){ if (Pnt[x]){ Expose(x); Pnt[Lch[x]]=0; Lch[x]=0; Update(x); } } int n,Q; void init(){ Total=0; memset(Rev,0,sizeof(Rev)); memset(Pnt,0,sizeof(Pnt)); memset(Lch,0,sizeof(Lch)); memset(Rch,0,sizeof(Rch)); memset(Sum,0,sizeof(Sum)); } char cmd[22]; int main() { init(); scanf("%d",&n); for (int i=1;i<=n;i++) scanf("%d",&Data[i]); scanf("%d",&Q); while (Q--){ int x,y; scanf("%s%d%d",cmd,&x,&y); if (cmd[0]=='p'){ Modify(x,y); } if (cmd[0]=='b'){ if (Join(x,y)) printf("yes\n"); else printf("no\n"); } if (cmd[0]=='e'){ int ans=Query(x,y); if (ans==-1) printf("impossible\n"); else printf("%d\n",ans); } } return 0; }
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 = 10010; int ch[MAXN][2],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][0]],Max[ch[r][1]]),key[r]); } void Rotate(int x) { int y = pre[x], kind = ch[y][1]==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]][1]==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][1]==f)==(ch[f][1]==r) ) Rotate(f), Rotate(r); else Rotate(r), Rotate(r); } push_up(r); } int Access(int x) { int y = 0; do { Splay(x); rt[ch[x][1]] = true, rt[ch[x][1]=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 = 0; while(u) { Splay(u); if(!pre[u])return; rt[ch[u][1]] = true; rt[ch[u][1]=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][1]])); } struct Edge { int to,next; int val; int index; }edge[MAXN*2]; 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 != -1;i = edge[i].next) { int v = edge[i].to; if(pre[v] != 0)continue; pre[v] = u; id[edge[i].index] = v; key[v] = edge[i].val; dfs(v); } } void init() { tot = 0; memset(head,-1,sizeof(head)); } int main() { //freopen("in.txt","r",stdin); //freopen("out.txt","w",stdout); int T; int n; int u,v,w; char op[20]; scanf("%d",&T); while(T--) { init(); scanf("%d",&n); for(int i = 0;i <= n;i++) { pre[i] = 0; ch[i][0] = ch[i][1] = 0; rt[i] = true; } Max[0] = -2000000000; for(int i = 1;i < n;i++) { scanf("%d%d%d",&u,&v,&w); addedge(u,v,w,i); addedge(v,u,w,i); } pre[1] = -1; dfs(1); pre[1] = 0; while(scanf("%s",&op) == 1) { if(op[0] == 'D')break; scanf("%d%d",&u,&v); if(op[0] == 'C') change(id[u],v); else query(u,v); } } return 0; }