【模板】【P3605】【USACO17JAN】Promotion Counting 晋升者计数——动态开点和线段树合并（树状数组/主席树）

（题面来自Luogu）

题目描述

奶牛们又一次试图创建一家创业公司，还是没有从过去的经验中吸取教训--牛是可怕的管理者！

为了方便，把奶牛从 1⋯N(1≤N≤100,000) 编号，把公司组织成一棵树，1 号奶牛作为总裁（这棵树的根节点）。除了总裁以外的每头奶牛都有一个单独的上司（它在树上的 “双亲结点”）。所有的第 i 头牛都有一个不同的能力指数 p(i)，描述了她对其工作的擅长程度。如果奶牛 i 是奶牛 j 的祖先节点（例如，上司的上司的上司），那么我们我们把奶牛 j 叫做 i 的下属。

不幸地是，奶牛们发现经常发生一个上司比她的一些下属能力低的情况，在这种情况下，上司应当考虑晋升她的一些下属。你的任务是帮助奶牛弄清楚这是什么时候发生的。简而言之，对于公司的中的每一头奶牛 i，请计算其下属 j 的数量满足 p(j)>p(i)。

输入格式

输入的第一行包括一个整数 N。

接下来的 N 行包括奶牛们的能力指数 p(1)⋯p(N). 保证所有数互不相同，在区间 1⋯⋯1e9 之间。

接下来的 N−1 行描述了奶牛 2⋯⋯N 的上司（父节点）的编号。再次提醒，1 号奶牛作为总裁，没有上司。

输出格式

输出包括 N 行。输出的第 i 行应当给出有多少奶牛 i 的下属比奶牛 i 能力高。

 

　　同样是大规模统计子树信息的问题，这题并不能拿启发式合并来做，因为子树内的要求信息和根节点的信息要求不同，与根本身的信息有关。换句话说，无法把重儿子的信息直接合并给根。

　　线段树合并的一般对象是两棵动态开点的权值线段树。权值线段树动态开点可以只见出建出没有被插入过的位置，时空复杂度O(nloginf)，可以节省很大的空间。查询时避开空节点即可。

代码：

  1. void modify(int &nd, int l, int r, int x) {  
  2.     if (!nd) nd = ++tot;  
  3.     if (l == r) {  
  4.         ++cnt[nd];  
  5.         return;  
  6.     }  
  7.     if (x <= mid) modify(lc[nd], l, mid, x);  
  8.     else modify(rc[nd], mid + 1, r, x);  
  9.     update(nd);  
  10. }  

　　动态开点是不需要离散化序列的，因为没有被访问到的值不会被建出来。不过在题目条件允许的情况下，离散化可以把线段树本身的空间和时间的复杂度都降到O(nlogn)，而离散化本身的复杂度又很小，可以视题目尽量加上。

　　线段树合并的过程很简单，它利用了动态开点线段树部分节点为空的性质，在递归的过程中直接暴力合并两棵线段树对应节点的信息，遇到空节点直接返回。合并函数写法有两种，前者通过新建线段树保留旧线段树的信息，后者直接利用原有节点，不需要额外开辟空间。静态子树统计的问题中每个节点返回后不会被再次访问，一般采用省空间的写法。

写法1:

  1. int merge(int &u, int v) {  
  2.     if (!v) return u;  
  3.     if (!u) return v;  
  4.     int nd = ++tot;  
  5.     cnt[nd] = cnt[lc[nd]] + cnt[rc[nd]];//把v的信息并到u上  
  6.     lc[nd] = merge(lc[u], lc[v]);  
  7.     rc[nd] = merge(rc[u], rc[v]);  
  8.     return nd;  
  9. }  

写法2:

  1. void merge(int &u, int v) {  
  2.     if (!u || !v) {//存在一个空节点  
  3.         u += v;//直接把u指向非空的那个点  
  4.         return;  
  5.     }  
  6.     seg[u].cnt += seg[v].cnt;//把v的信息并到u上  
  7.     merge(lc[u], lc[v]);  
  8.     merge(rc[u], rc[v]));  
  9.     return;  
  10. }  

　　时间复杂度证明：假设最初存在的线段树共有O(nlogn)级别的节点数。每一次合并操作至少会减少一个原有节点，所以总复杂度的上界就是O(nlogn)的。

　　线段树合并常数比树上启发式合并大一些，能承受的范围大概在1e6左右。不过由于每个节点合并起来得到的线段树是分开统计的，它更普适于类似的子树统计问题。

　　其实该题中的查询子树权值信息和合并操作，用树状数组就可以维护。更神仙的做法是暴上主席树……但是作为线段树合并的模板还是要认真打的……

　　考虑对每个叶子节点维护一棵权值线段树，然后递归地合并一个节点u的每一个子节点中的线段树，在这棵树上查询比能力值score[u]大的节点数就等价于查询[score[u] + 1, inf]的区间和。然后把score[u]插入该线段树中即可返回。由于只需要比较大小关系，可以做离散化来优化时间复杂度。

代码：

  1. #include <iostream>  
  2. #include <cstdio>  
  3. #include <cstring>  
  4. #include <algorithm>  
  5. #define BUG puts("$$$")  
  6. #define maxn 100010  
  7. template <typename T>   
  8. void read(T &x) {  
  9.     x = 0;  
  10.     char ch = getchar();  
  11. //  int f = 1;  
  12.     while (!isdigit(ch)) {  
  13. //      if (ch == '-') f = -1;   
  14.         ch = getchar();  
  15.     }  
  16.     while (isdigit(ch)) {  
  17.         x = x * 10 + (ch ^ 48);  
  18.         ch = getchar();  
  19.     }  
  20. //  x *= f;  
  21. }  
  22. using namespace std;  
  23. int n, N;  
  24. int head[maxn], top;   
  25. struct E {  
  26.     int to, nxt;  
  27. } edge[maxn << 1];  
  28. inline void insert(int u, int v) {  
  29.     edge[++top] = (E) {v, head[u]};  
  30.     head[u] = top;  
  31. }  
  32. int score[maxn];  
  33. namespace Segment_tree {  
  34.     #define mid ((l + r) >> 1)  
  35.     int tot = 0;  
  36.     struct node {  
  37.         int cnt, lc, rc;  
  38.         node(): cnt(0), lc(0), rc(0) {}  
  39.     } seg[maxn << 4];  
  40.     #define lc(nd) seg[nd].lc  
  41.     #define rc(nd) seg[nd].rc  
  42.     void update(int nd) {  
  43.         seg[nd].cnt = seg[lc(nd)].cnt + seg[rc(nd)].cnt;  
  44.     }  
  45.     void modify(int &nd, int l, int r, int x) {  
  46.         if (!nd) nd = ++tot;  
  47.         if (l == r) {  
  48.             ++seg[nd].cnt;  
  49.             return;  
  50.         }  
  51.         if (x <= mid) modify(lc(nd), l, mid, x);  
  52.         else modify(rc(nd), mid + 1, r, x);  
  53.         update(nd);  
  54.     }  
  55.     int query(int nd, int l, int r, int ql, int qr) {  
  56.         if (!nd) return 0;  
  57.         if (l >= ql && r <= qr)  
  58.             return seg[nd].cnt;  
  59.         if (l > qr || r < ql)  
  60.             return 0;  
  61.         return query(lc(nd), l, mid, ql, qr) + query(rc(nd), mid + 1, r, ql, qr);  
  62.     }  
  63.     void merge(int &u, int v) {  
  64.         if (!u || !v) {  
  65.             u += v;  
  66.             return;  
  67.         }  
  68.         seg[u].cnt += seg[v].cnt;  
  69.         merge(lc(u), lc(v));  
  70.         merge(rc(u), rc(v));  
  71.         return;  
  72.     }  
  73.     int ans[maxn], rt[maxn];  
  74.     void solve(int u) {//核心代码
  75.         for (int i = head[u]; i; i = edge[i].nxt) {  
  76.             int v = edge[i].to;  
  77.             solve(v);  
  78.             merge(rt[u], rt[v]);  
  79.         }  
  80.         ans[u] = query(rt[u], 1, N, score[u] + 1, N);  
  81.         modify(rt[u], 1, N, score[u]);  
  82.         return;  
  83.     }  
  84. } using namespace Segment_tree;  
  85. int st[maxn];  
  86. int contra(int *a) {//离散化
  87.     memcpy(st, a, sizeof(st));  
  88.     sort(st + 1, st + 1 + n);  
  89.     int len = unique(st + 1, st + 1 + n) - st - 1;  
  90.     for (int i = 1; i <= n; ++i)  
  91.         a[i] = lower_bound(st + 1, st + 1 + len, a[i]) - st;  
  92.     return len;  
  93. }  
  94.   
  95. int main() {  
  96.     read(n);  
  97.     int u, v;  
  98.     for (int i = 1; i <= n; ++i)  
  99.         read(score[i]);  
  100.     N = contra(score);  
  101.     for (u = 2; u <= n; ++u) {  
  102.         read(v);  
  103.         insert(v, u);  
  104.     }  
  105.     solve(1);  
  106.     for (int i = 1; i <= n; ++i)  
  107.         printf("%d\n", ans[i]);  
  108.     return 0;  
  109. }  

 

posted @ 2019-08-14 09:02  onyYuan  阅读(195)  评论(0)  编辑  收藏  举报