Luogu 4556 雨天的尾巴 - 启发式合并线段树

Solution

用$col$记录 数量最多的种类， $sum$记录 种类$col$ 的数量。

然后问题就是树上链修改， 求 每个节点 数量最多的种类。

用树上差分 + 线段树合并更新即可。

Code

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define rd read()
 using namespace std;

 const int N = 1e5 + ;

 int head[N], cnt;
 int n, m;
 int sum[N], top[N], son[N], sz[N], f[N], dep[N];
 int u[N], v[N], z[N], b[N], tot, ans[N], idf[N];

 struct edge {
     int nxt, to;
 }e[N << ];

 int read() {
     int X = , p = ; char c = getchar();
     for (; c > '' || c < ''; c = getchar())
         if (c == '-') p = -;
     for (; c >= '' && c <= ''; c = getchar())
         X = X *  + c - '';
     return X * p;
 }

 void add(int u, int v) {
     e[++cnt].to = v;
     e[cnt].nxt = head[u];
     head[u] = cnt;
 }

 int fd(int x) {
     return lower_bound(b + , b +  + tot, x) - b;
 }

 namespace SegT {

     struct node {
         int sum, col, lson, rson;
         node() {
             sum = col = lson = rson = ;
         }
     } s[N * ];

     int root[N];

 #define lc(p) s[p].lson
 #define rc(p) s[p].rson
 #define sum(p) s[p].sum
 #define col(p) s[p].col
 #define mid ((l + r) >> 1)

     int st[N * ], tp, qnum;

     int get() {
         if (tp) {
             int re = st[tp];
             tp--;
             return re;
         }

         else return ++qnum;
     }

     void del(int x) {
         lc(x) = rc(x) = sum(x) =  col(x) = ;
         st[++tp] = x;
     }

     void up(int p) {
         if(sum(lc(p)) >= sum(rc(p)))
             sum(p) = sum(lc(p)), col(p) = col(lc(p));
         else
             sum(p) = sum(rc(p)), col(p) = col(rc(p));
     }

     void modify(int l, int r, int pos, int d, int &x) {
         if(!x) x = get();
         if (l == r) {
             sum(x) += d;
             if (sum(x) > )
                 col(x) = pos;
             return;
         }
         if (pos <= mid)
             modify(l, mid, pos, d, lc(x));
         else
             modify(mid + , r, pos, d, rc(x));
         up(x);
     }

     int merge(int l, int r, int x, int y) {
         if (!x || !y)
             return x + y;
         int now = get();
         if (l == r) {
             sum(now) = sum(x) + sum(y);
             if (sum(now) > )
                 col(now) = max(col(x), col(y));
             else col(now) = ;
         }
         else {
             lc(now) = merge(l, mid, lc(x), lc(y));
             rc(now) = merge(mid + , r, rc(x), rc(y));
             up(now);
         }
         del(x); del(y);
         return now;
     }
 }

 using namespace SegT;

 namespace SP {
     void dfs1(int x) {
         sz[x] = ;
         for (int i = head[x]; i; i = e[i].nxt) {
             int nt = e[i].to;
             if (nt == f[x])
                 continue;
             f[nt] = x;
             dep[nt] = dep[x] + ;
             SP::dfs1(nt);
             sz[x] += sz[nt];
             if (sz[nt] > sz[son[x]])
                 son[x] = nt;
         }
     }

     void dfs2(int x) {
         if (!son[x])
             return;
         top[son[x]] = top[x];
         SP::dfs2(son[x]);
         for (int i = head[x]; i; i = e[i].nxt) {
             int nt = e[i].to;
             if (nt == f[x] || nt == son[x])
                 continue;
             top[nt] = nt;
             SP::dfs2(nt);
         }
     }

     int LCA(int x, int y) {
         for (; top[x] != top[y];) {
             if (dep[top[x]] < dep[top[y]])
                 swap(x, y);
             x = f[top[x]];
         }
         if (dep[x] < dep[y])
             swap(x, y);
         return y;
     }

     void solve(int x) {
         for (int i = head[x]; i; i = e[i].nxt) {
             int nt = e[i].to;
             if (nt == f[x])
                 continue;
             SP::solve(nt);
             root[x] = merge(, tot, root[x], root[nt]);
         }
         ans[x] = col(root[x]);
     }
 }

 int main()
 {
     n = rd; m = rd;
     for (int i = ; i < n; ++i) {
         int x = rd, y = rd;
         add(x, y); add(y, x);
     }
     dep[] = ;
     SP::dfs1();
     top[] = ;
     SP::dfs2();
     for (int i = ; i <= m; ++i) {
         u[i] = rd; v[i] = rd;
         z[i] = b[i] = rd;
     }
     tot = m;
     sort(b + , b +  + tot);
     tot = unique(b + , b +  + tot) - b - ;
     for (int i = ; i <= tot; ++i)
         idf[b[i]] = i;
     for (int i = ; i <= m; ++i) {
         int lca = SP::LCA(u[i], v[i]);
         modify(, tot, idf[z[i]], , root[u[i]]);
         modify(, tot, idf[z[i]], , root[v[i]]);
         modify(, tot, idf[z[i]], -, root[lca]);
         modify(, tot, idf[z[i]], -, root[f[lca]]);
     }
     SP::solve();
     for (int i = ; i <= n; ++i)
         printf("%d\n" ,b[ans[i]]);
 }