【数据结构模版】可持久化线段树 && 主席树

　　浙江集训Day4，从早8:00懵B到晚21：00，只搞懂了可持久化线段树以及主席树的板子。今天只能记个大概，以后详细完善讲解。

　　可持久化线段树指的是一种基于线段树的可回溯历史状态的数据结构。我们想要保存某一段序列的历史信息，可以朴素地开m倍的空间存储；而线段树是一种优秀的数据结构，它每次修改操作只把原先的数据修改log个节点，这就意味着我们只增加这些被修改的节点存储新信息就好了。传统的线段树用二叉树存储，但是因为涉及加点，可持久化线段树必须维护一个自增的tot动态成为新点的编号。对于每个节点，我们要维护两个指针指向它的左右子节点。对于每次修改，我们把新节点的不被修改的一半区间指向上个状态该区间的节点编号，等同于利用了上次的区间信息；另一半新开一个点继续递归下去即可。

　　可持久化线段树一般不能维护区间修改，因为多个根共享子节点，我们没有办法对每个状态的树独立维护它的lazy_tag。

代码（动态开点&&区间最大值）：

  1. #include <iostream>  
  2. #include <cstdio>  
  3. #include <cstring>  
  4. #include <algorithm>  
  5. #include <climits>  
  6. #define maxn 1000100  
  7. #define maxm 1000100  
  8. #define LG 21  
  9. #define BUG putchar('*')  
  10. using namespace std;  
  11. template <typename T>  
  12. void read(T &x) {  
  13.     x = 0;  
  14.     int f = 1;  
  15.     char ch = getchar();  
  16.     while (!isdigit(ch)) {  
  17.         if (ch == '-')  
  18.             f = -1;  
  19.         ch = getchar();  
  20.     }  
  21.     while (isdigit(ch)) {  
  22.         x = x * 10 + (ch ^ 48);  
  23.         ch = getchar();  
  24.     }  
  25.     x *= f;  
  26.     return;  
  27. }  
  28.   
  29. int n, m, a[maxn];  
  30. namespace Segment_tree {  
  31.     int root[maxm], tot;  
  32.     struct node {  
  33.         int dat, lc, rc;  
  34.           
  35.     } seg[maxn * 20];  
  36.     inline void update(int nd) {  
  37.         seg[nd].dat = max(seg[seg[nd].lc].dat, seg[seg[nd].rc].dat);   
  38.     }  
  39.     int build(int l, int r) {  
  40.         int nd = ++tot;  
  41.         if (l == r) {  
  42.             seg[nd].dat = a[l];  
  43.             return nd;  
  44.         }  
  45.         int mid = (l + r) >> 1;  
  46.         seg[nd].lc = build(l, mid), seg[nd].rc = build(mid + 1, r);  
  47.         update(nd);  
  48.         return nd;  
  49.     }  
  50.     int modify(int nd, int l, int r, int x, int val) {  
  51.         int now = ++tot;  
  52.         seg[now] = seg[nd];  
  53.         if (l == r) {  
  54.             seg[now].dat = val;  
  55.             return now;  
  56.         }  
  57.         int mid = (l + r) >> 1;  
  58.         if (x <= mid)  
  59.             seg[now].lc = modify(seg[nd].lc, l, mid, x, val);  
  60.         else seg[now].rc = modify(seg[nd].rc, mid + 1, r, x, val);  
  61.         update(now);  
  62.         return now;  
  63.     }  
  64.     int query(int nd, int l, int r, int ql, int qr) {  
  65.         if (ql <= l && qr >= r)  
  66.             return seg[nd].dat;  
  67.         if (ql > r || qr < l)  
  68.             return INT_MIN;  
  69.         int mid = (l + r) >> 1;  
  70.         return max(query(seg[nd].lc, l, mid, ql, qr), query(seg[nd].rc, mid + 1, r, ql, qr));  
  71.     }  
  72. } using namespace Segment_tree;  
  73. int main() {  
  74.     read(n), read(m);  
  75.     for (int i = 1; i <= n; ++i)  
  76.         read(a[i]);  
  77.     root[0] = build(1, n);  
  78.     int k, op, val, loc, l, r;  
  79.     for (int i = 1; i <= m; ++i) {  
  80.         read(k), read(op);  
  81.         if (op == 1) {  
  82.             read(loc), read(val);  
  83.             root[i] = modify(root[k], 1, n, loc, val);  
  84.         } else {  
  85.             read(l), read(r);  
  86.             printf("%d\n", query(root[k], 1, n, l, r));  
  87.             root[i] = root[k];  
  88.         }  
  89.     }  
  90.     return 0;  
  91. }  

　　听说主席树是由fotile96主席发明的（总之是位神犇就对了）。主要用于维护数据区间的值域问题。

　　给定一段区间，每次询问l,r区间内的第k小值。主席树是一个可持久化权值线段树：我们将右端点r抽象成时刻，建立（数据长度）个根，以root[t]表示区间[1, t]所维护的权值线段树的根。（模板题的权值需要离散化）如果查询[l, r]，我们找出第l-1和第r棵线段树（将root[0]建成一棵空树），这两棵树对应节点信息做差，实质上就得到了一棵仅维护区间[l, r]的虚拟线段树的信息。我们动态跑出这棵树的同时二分它的左右子树：如果这棵虚拟树的左端点权值和sum大于等于k，说明第k大数在[l, mid]中，我们转而查询这段的第k大：如果sum小于k，说明所求数是区间[mid + 1, r]的第k-sum大数。实际上，在区间Kth数问题中，主席树以类似前缀和的思想维护了虚拟的维护[l, r]信息的权值线段树来查询对应区间信息的。

　代码：

  1. #include <iostream>  
  2. #include <cstdio>  
  3. #include <cstring>  
  4. #include <algorithm>  
  5. #include <climits>  
  6. #define maxn 200100  
  7. #define maxm 200100  
  8. #define LG 21  
  9. #define BUG putchar('*')  
  10. using namespace std;  
  11. int n, m;  
  12.   
  13. template <typename T>  
  14. void read(T &x) {  
  15.     x = 0;  
  16.     int f = 1;  
  17.     char ch = getchar();  
  18.     while (!isdigit(ch)) {  
  19.         if (ch == '-')  
  20.             f = -1;  
  21.         ch = getchar();  
  22.     }  
  23.     while (isdigit(ch)) {  
  24.         x = x * 10 + (ch ^ 48);  
  25.         ch = getchar();  
  26.     }  
  27.     x *= f;  
  28.     return;  
  29. }  
  30.   
  31. namespace Contra {  
  32.     int st[maxn];  
  33.     int work(int *org, int *st) {  
  34.         for (int i = 1; i <= n; ++i)  
  35.             st[i] = org[i];  
  36.         sort(st + 1, st + 1 + n);  
  37.         int len = unique(st + 1, st + n + 1) - (st + 1);  
  38.         for (int i = 1; i <= n; ++i)  
  39.             org[i] = lower_bound(st + 1, st + len + 1, org[i]) - st;  
  40.   
  41.         return len;  
  42.     }  
  43. }  
  44. int a[maxn], N;  
  45. namespace President_tree {  
  46.     #define lc(i) seg[(i)].lc   
  47.     #define rc(i) seg[(i)].rc    
  48.     using namespace Contra;  
  49.     int tot, root[maxm];  
  50.     struct node {  
  51.         int cnt, lc, rc;  
  52.     } seg[maxm * 20];  
  53.     void update(int nd) {  
  54.         seg[nd].cnt = seg[lc(nd)].cnt + seg[rc(nd)].cnt;  
  55.     }  
  56.     int build(int l, int r) {//root[0]:empty_tree  
  57.         int nd = ++tot;  
  58.         if (l == r) return nd;  
  59.         int mid = (l + r) >> 1;  
  60.         seg[nd].lc = build(l, mid);  
  61.         seg[nd].rc = build(mid + 1, r);  
  62.         return nd;  
  63.     }  
  64.     int modify(int pre, int l, int r, int x) {  
  65.         int nd = ++tot;  
  66.         seg[nd] = seg[pre];  
  67.         if (l == r) {  
  68.             ++seg[nd].cnt;   
  69.             return nd;  
  70.         }  
  71.         int mid = (l + r) >> 1;  
  72.         if (x <= mid)  
  73.             lc(nd) = modify(lc(pre), l, mid, x);  
  74.         else   
  75.             rc(nd) = modify(rc(pre), mid + 1, r, x);  
  76.         update(nd);  
  77.         return nd;  
  78.     }  
  79.     int query(int ql, int qr, int l, int r, int k) {  
  80.         if (l == r) {  
  81.             return st[l];   
  82.         }  
  83.         int mid = (l + r) >> 1, sum = seg[lc(qr)].cnt - seg[lc(ql)].cnt;  
  84.         if (k <= sum)  
  85.             return query(lc(ql), lc(qr), l, mid, k);  
  86.         return query(rc(ql), rc(qr), mid + 1, r, k - sum);  
  87.     }  
  88.     void init() {  
  89.         N = work(a, st);  
  90.         root[0] = build(1, N);  
  91.         for (int i = 1; i <= n; ++i) {  
  92.             root[i] = modify(root[i - 1], 1, N, rk[i]);  
  93.         }  
  94.     }  
  95. } using namespace President_tree;  
  96.   
  97. int main() {  
  98.     read(n), read(m);  
  99.     for (int i = 1; i <= n; ++i)  
  100.         read(a[i]);  
  101.     init();  
  102.     int l, r, k;  
  103.     for (int i = 1; i <= m; ++i) {  
  104.         read(l), read(r), read(k);  
  105.         printf("%d\n", query(root[l - 1], root[r], 1, N, k));  
  106.     }  
  107.     return 0;  
  108. }  

 

 

　　

　　

posted @ 2019-07-09 21:40  onyYuan  阅读(193)  评论(0)  编辑  收藏  举报