LinkCutTree 总结

最近学习了LinkCutTree，总结一下。

LinkCutTree是一种数据结构（是Tree Decomposition中的一种），她维护的一般是无向图（一个森林），支持连边、删边、链修改、链查询（点属于特殊的链，修改可以是单点修改、整链修改，查询可以是最值、和等）这四种操作。

中心思想是将边分类，一类边组成一些连续的链，每条链保存在一颗BST中（一般是Splay），BST中以点到根的距离为关键字（左边的点是右边的点的祖先），其它一些边连接这些链。（LinkCutTree是树链剖分（又叫轻重链剖分）的动态版本，并且更灵活），可以证明，LinkCutTree的各种操作都是均摊O(logn)的（渐进复杂度比树链剖分的O(log^2)还好，但是常数巨大，所以实测一般时间是树链剖分的1.5~2倍）。

上面的“链修改、链查询”指的是链上的点，如果要将对象改为边，可以为每条边建立一个边点，即若存在边(u,v)，则新加一个点z代表边，将z连接u和v，z的点权就是(u,v)的边权，非边点的权设为-oo），然后对边权的统计就变成了对点权的统计（这是LCT中处理边信息的通法之一）。

 #include <cstdio>
 #include <iostream>
 #define maxn 10010
 using namespace std;

 /*
 我的代码风格：用数组模拟指针和结构体。
 变量含义：
 pnt[u] - path-parent of u in the tree
 pre[u] - the father of u in the Splay
 son[u][0] - the left child of u in the Splay
 son[u][1] - the right child of u in the Splay
 val[u] - the weight of u
 sum[u] - the sum of weight of all the nodes in the subtree of u
 siz[u] - the number of the nodes in the subtree of u
 itg[u] - increasement tag ( the lazy tag )
 rtg[u] - rotate tag ( the lazy tag )
  */
 /*
 模板功能：支持删边和连边，支持将一条链的点权做一个增量，支持查询一条链的点权和，判断两点是否再同一联通块中
 因为是自己想的一个功能，所以没有地方交，不保证代码正确性。(重在理解）
 代码中哪里不懂欢迎回复，代码丑别喷。
 */
 namespace L {
     int pnt[maxn], pre[maxn], son[maxn][], val[maxn],
         sum[maxn], siz[maxn], itg[maxn], rtg[maxn];

     void update( int nd ) {
         sum[nd] = val[nd] + sum[son[nd][]] + sum[son[nd][]];
     }
     void rotate( int nd, int d ) {
         int p = pre[nd];
         int s = son[nd][!d];
         int ss = son[s][d];

         son[nd][!d] = ss;
         son[s][d] = nd;
         if( p ) son[p][ nd==son[p][] ] = s;
         else pnt[s] = pnt[nd];

         pre[nd] = s;
         pre[s] = p;
         pre[ss] = nd;

         update( nd );
         update( s );
     }
     void pushdown( int nd ) {
         if( rtg[nd] ) {
             int &ls = son[nd][], &rs = son[nd][];
             swap(ls,rs);
             rtg[ls] ^= ;
             rtg[rs] ^= ;
             rtg[nd] = ;
         }
         if( itg[nd] ) {
             int ls = son[nd][], rs = son[nd][];
             int delta = itg[nd];
             itg[ls] += delta;
             itg[rs] += delta;
             val[ls] += delta;
             val[rs] += delta;
             sum[ls] += siz[ls]*delta;
             sum[rs] += siz[rs]*delta;
             itg[nd] = ;
         }
     }
     void big_push( int nd ) {
         if( pre[nd] ) big_push(pre[nd]);
         pushdown(nd);
     }
     void splay( int nd, int top= ) {
         big_push(nd);
         while( pre[nd]!=top ) {
             int p = pre[nd];
             int nl = nd==son[p][];
             if( pre[p]==top ) {
                 rotate( p, nl );
             } else {
                 int pp = pre[p];
                 int pl = p==son[pp][];
                 if( nl==pl ) {
                     rotate( pp, pl );
                     rotate( p, nl );
                 } else {
                     rotate( p, nl );
                     rotate( pp, pl );
                 }
             }
         }
     }
     void access( int nd ) {
         int u = nd;
         int v = ;
         while( u ) {
             splay( u );
             int s = son[u][];
             pre[s] = ;
             pnt[s] = u;
             pre[v] = u;
             son[u][] = v;
             update( u );
             v = u;
             u = pnt[u];
         }
         splay( nd );
     }
     int findroot( int nd ) {
         while( pre[nd] ) nd=pre[nd];
         while( pnt[nd] ) {
             nd = pnt[nd];
             while( pre[nd] ) nd=pre[nd];
         }
         return nd;
     }
     void makeroot( int nd ) {
         access( nd );
         rtg[nd] ^= ;
     }
     bool sameroot( int u, int v ) {
         return findroot(u)==findroot(v);
     }
     void link( int u, int v  ){
         makeroot(u);
         makeroot(v);
         pnt[u] = v;
     }
     void cut( int u, int v ) {
         makeroot(u);
         access(v);
         pnt[u] = ;
         pre[u] = ;
         son[v][] = ;
         update( v );
     }
     void up_val( int u, int v, int delta ) {
         makeroot(u);
         access(v);
         val[v] += delta;
         sum[v] += siz[v]*delta;
         itg[v] += delta;
     }
     int qu_sum( int u, int v ) {
         makeroot(u);
         access(v);
         return val[v]+sum[son[v][]];
     }
 };
 /*
 int main() {
     L::link(1,2);
     L::link(2,3);
     L::link(3,4);
     L::up_val(1,3,3);
     L::up_val(2,4,-3);
     printf( "%d\n", L::qu_sum(1,1) );
     printf( "%d\n", L::qu_sum(2,2) );
     printf( "%d\n", L::qu_sum(3,3) );
     printf( "%d\n", L::qu_sum(4,4) );
     printf( "%d\n", L::qu_sum(2,3) );
 }
 */
 int main() {
     L::link(,);
     L::link(,);
     L::link(,);
     L::up_val( , ,  );
     L::cut(,);
     printf( "%d\n", L::qu_sum(,) );
     printf( "%d\n", L::qu_sum(,) );
     printf( "%d\n", L::sameroot(,) );
 }

推荐学习资料：

杨思雨 《伸展树的基本操作与应用》

杨哲 《QTREE解法的一些研究》

http://blog.csdn.net/d891320478/article/details/9181385