浅谈树链剖分 F&Q

  这是一篇迟来的博客,由于我懒得写文章,本篇以两个问题阐述笔者对树链剖分的初步理解。

Q1:树链剖分解决什么问题?

  树链剖分,就是把一棵树剖分成若干连续的链,将这些链里的数据映射在线性数组上维护。比方说我们想要维护树上任意两点间的lca,或者支持一段路径或一棵子树的修改和查询,都可以用树链剖分来解决。

Q2:树链剖分是什么原理?

  以经典的重链剖分为例,列举笔者认为是树剖核心的两个基本数据结构性质:

  1、树剖序:树剖所维护的几个基本信息如dfn(时间戳)、size(子树大小)、fa(树上父亲),在这里不过多赘述。这里只分析基于son(重儿子)所得出的树剖序的本质。

  我们在打时间戳遍历原树的时候,实际上做了遍特殊的dfs,这个dfs以优先遍历重儿子为原则,对应的dfs序实际上就是树剖序。换言之,树剖序是一种特殊的dfs序,它首先符合dfs序的特征,如“u的子树在树剖序里是一段连续区间”这样的性质支持我们可以用区间数据结构(线段树)来维护子树的信息。

  同时,树剖序有自己的独特性质。相信能看到这篇博客的同学都对所谓“重链”有了了解:每条重链都是由叶子结点沿返祖边指向祖先方向的一条树链,它上面除了最浅的一个点以外的所有结点都是对应祖先的重儿子。两条重链之间通过一条轻边衔接。既然我们优先遍历重儿子,每段重链在树剖序上都是一段连续的区间:而每个节点要么是重儿子(在重链上),要么是某条重链的起点;那么每个节点都一定且仅属于某条重链。所以我们按树剖序得到的线性数组就是由若干条重链拼成的,我们可以在其上用维护区间的方法便可以维护整棵树的信息。

  2、重链的优越性

  那么,树链剖分的高效性何在?首先,我们记录每个点所在重链的链头,从某一点转移到链头的复杂度是O(1)的。修改、查询每段树链用线段树log级维护。而我们需要沿轻边跳跃多少次就可以覆盖整条路径呢?

  引理:任一点到根节点的轻边最多有log条。

  这实际上是个很显然的性质:最坏的情况就是每条边都是轻边,每次从轻儿子v跳到u,由于size[v] < size[son[u]],子树的大小便至少会增加一倍,那么最多会增加log次,这就是我们要按轻重剖分的原因。

  于是树链剖分每次询问都1最坏时间为O(logn*logn),实际上很难有极端数据来卡到这个限度,一般还是很优秀的。(笔者用树链剖分打出的lca板子居然跑得和倍增一样快)

 

  至此树剖的整体思路已经明了,我们在剖分出的线性区间内架起一棵线段树来维护树上信息即可。下面附上我的树剖代码,码风应该比较清爽,其中线段树的写法也是从大佬那里抄来的精华。希望对各位学习树剖的同学有所帮助。

  1. #include <iostream>  
  2. #include <cctype>  
  3. #include <cstdio>  
  4. #define maxn 100010  
  5. #define BUG putchar('*')  
  6. using namespace std;  
  7. template <typename T>  
  8. void read(T &x) {  
  9.     x = 0;  
  10.     int f = 1;  
  11.     char ch = getchar();  
  12.     while (!isdigit(ch)) {  
  13.         if (ch == '-')  
  14.             f = -1;  
  15.         ch = getchar();  
  16.     }  
  17.     while (isdigit(ch)) {  
  18.         x = x * 10 + (ch ^ 48);  
  19.         ch = getchar();  
  20.     }  
  21.     x *= f;  
  22.     return;  
  23. }  
  24. int mod;  
  25. int head[maxn], top;  
  26. int n, m, root;  
  27. int val[maxn], w[maxn];  //共计三个数据数组:原始值、树剖序对应值和线段树
  28. struct E {  
  29.     int to, nxt;  
  30. } edge[maxn << 1];  
  31. inline void insert(int u, int v) {  
  32.     edge[++top] = (E) {v, head[u]};  
  33.     head[u] = top;  
  34. }  
  35. namespace segement_tree {   //线段树部分
  36.     #define lc (nd<<1)  
  37.     #define rc ((nd<<1)|1)  
  38.     struct node {  
  39.         int val, len;  
  40.         inline friend node operator + (node a, node b) {  
  41.             return (node) {(a.val + b.val) % mod, a.len + b.len};  
  42.         }  
  43.     } data[maxn << 2];  
  44.     int tag[maxn << 2];   //lazy_tag只维护简单的加减
  45.     inline node operator * (node a, int b) {  
  46.         return (node) {a.val + (b * a.len) % mod, a.len};  
  47.     }  
  48.     inline void put_tag(int nd, int del) {  
  49.         data[nd] = data[nd] * del;  
  50.         tag[nd] = tag[nd] + del;  
  51.     }  
  52.     inline void update(int nd) {  
  53.         data[nd] = data[lc] + data[rc];  
  54.     }  
  55.     inline void push_down(int nd) {   //下推,同时释放当前节点的tag信息
  56.         put_tag(lc, tag[nd]);  
  57.         put_tag(rc, tag[nd]);  
  58.         tag[nd] = 0;  
  59.     }  
  60.     void build(int nd, int l, int r) {  
  61.         if (l == r) {  
  62.             data[nd] = (node) {w[l], 1};  
  63.             return;  
  64.         }  
  65.         int mid = (l + r) >> 1;  
  66.         build(lc, l, mid);  
  67.         build(rc, mid + 1, r);  
  68.         update(nd);  
  69.     }  
  70.     void modify(int nd, int l, int r, int ql, int qr, int del) {  
  71.         if (l >= ql && r <= qr) {  
  72.             put_tag(nd, del);  
  73.             return;  
  74.         } else if (l > qr || r < ql)  
  75.             return;  
  76.         push_down(nd);  
  77.         int mid = (l + r) >> 1;  
  78.         modify(lc, l, mid, ql ,qr, del);  
  79.         modify(rc, mid + 1, r, ql, qr, del);  
  80.         update(nd);  
  81.     }  
  82.     int query(int nd, int l, int r, int ql, int qr) {  
  83.         if (l >= ql && r <= qr) {  
  84.             return data[nd].val;  
  85.         } else if (l > qr || r < ql)  
  86.             return 0;  
  87.         push_down(nd);  
  88.         int mid = (l + r) >> 1;  
  89.         return (query(lc, l, mid, ql, qr) + query(rc, mid + 1, r, ql, qr)) % mod;  
  90.     }  
  91. }  
  92. namespace Divtree {  
  93.     using namespace segement_tree;  //我感觉这个写法挺好的,表明了树剖对线段树的调用关系
  94.     int ftop[maxn], f[maxn], size[maxn], son[maxn], d[maxn];  
  95.     int timer;  
  96.     int id[maxn];//树剖序   
  97.     void dfs1(int u, int pre) {   //第一次dfs,维护节点的深度、父亲、重量以及重儿子信息
  98.         f[u] = pre;  
  99.         size[u] = 1;  
  100.         d[u] = d[pre] + 1;  
  101.         for (int i = head[u]; i; i = edge[i].nxt) {  
  102.             int v = edge[i].to;  
  103.             if (v == pre) continue;  
  104.             dfs1(v, u);  
  105.             size[u] += size[v];  
  106.             if (size[v] > size[son[u]])  
  107.                 son[u] = v;  
  108.         }  
  109.     }  
  110.     void dfs2(int u, int tp) {    //按树剖序遍历,把树上信息剖分在线性数组上
  111.         ftop[u] = tp;  
  112.         id[u] = ++timer;  
  113.         w[timer] = val[u];   //拷贝
  114.         if (son[u])  
  115.             dfs2(son[u], tp);  //搭建当前重链
  116.         for (int i = head[u]; i; i = edge[i].nxt) {  
  117.             int v = edge[i].to;  
  118.             if (v != f[u] && v != son[u])  
  119.                 dfs2(v, v);   //沿轻边搭建新的重链
  120.         }  
  121.     }  
  122.     void init() {  
  123.         dfs1(root, root);  
  124.         dfs2(root, root);  
  125.         build(1, 1, n);  
  126.     }  
  127.     inline void Msub(int u, int del) {  
  128.         modify(1, 1, n, id[u], id[u] + size[u] - 1, del);   
  129.     }  
  130.     inline int Qsub(int u) {  
  131.         return query(1, 1, n, id[u], id[u] + size[u] - 1) % mod;  
  132.     }  
  133.     void Mrange(int u, int v, int del) {  
  134.         while (ftop[u] != ftop[v]) {  
  135.             if (d[ftop[u]] < d[ftop[v]])  
  136.                 swap(u, v);  
  137.             modify(1, 1, n, id[ftop[u]], id[u], del);   
  138.             u = f[ftop[u]];  
  139.         }  
  140.         if (d[u] > d[v]) swap(u, v);  
  141.         modify(1, 1, n, id[u], id[v], del);  
  142.     }  
  143.     int Qrange(int u, int v) {  
  144.         int ans = 0;  
  145.         while (ftop[u] != ftop[v]) {  
  146.             if (d[ftop[u]] < d[ftop[v]])  
  147.                 swap(u, v);  
  148.             ans = (ans + query(1, 1, n, id[ftop[u]], id[u])) % mod;  
  149.             u = f[ftop[u]];  
  150.         }  
  151.         if (d[u] > d[v]) swap(u, v);  
  152.         ans = (ans + query(1, 1, n, id[u], id[v])) % mod;  
  153.         return ans;  
  154.     }  
  155. using namespace Divtree;  
  156. int main() {  
  157.     read(n), read(m), read(root), read(mod);  
  158.     int u, v, del;  
  159.     for (int i = 1; i <= n; ++i)  
  160.         read(val[i]);  
  161.     for (int i = 1; i < n; ++i) {  
  162.         read(u), read(v);  
  163.         insert(u, v), insert(v, u);  
  164.     }  
  165.     init();  
  166.     register char ch;  
  167.     while (m--) {  
  168.         ch = getchar();  
  169.         while (!isdigit(ch)) ch = getchar();  
  170.         if (ch == '1') {  
  171.             read(u), read(v), read(del);  
  172.             Mrange(u, v, del);  
  173.         } else if (ch == '2') {  
  174.             read(u), read(v);  
  175.             printf("%d\n", Qrange(u, v));  
  176.         } else if (ch == '3') {  
  177.             read(u), read(del);  
  178.             Msub(u, del);  
  179.         } else {  
  180.             read(u);  
  181.             printf("%d\n", Qsub(u));  
  182.         }  
  183.     }  
  184.     return 0;  
  185. }  

 

posted @ 2019-07-07 19:00  onyYuan  阅读(214)  评论(0编辑  收藏  举报