dsu+树链剖分+树分治

dsu，对于无修改子树信息查询，并且操作支持undo的问题

暴力dfs，对于每个节点，对所有轻儿子dfs下去，然后再消除轻儿子的影响

dfs重儿子，然后dfs暴力恢复轻儿子们的影响，再把当前节点影响算进去

就有了整棵子树的信息了，时间复杂度O(nlogn)

经典例题:http://codeforces.com/contest/600/problem/E

 #include <bits/stdc++.h>

 using namespace std;

 typedef long long ll;

 const int N = 1e5 + ;

 int n, c[N];

 int cnt[N], maxCnt;

 int siz[N], son[N];

 vector <int> e[N];

 ll ans[N], sum[N];

 void dfs1(int u, int fr) {
     siz[u] = ;
     for (int v : e[u]) {
         if (v == fr) continue;
         dfs1(v, u);
         siz[u] += siz[v];
         if (siz[v] > siz[son[u]]) son[u] = v;
     }
 }

 void update(int x, int y) {
     sum[cnt[x]] -= x;
     cnt[x] += y;
     sum[cnt[x]] += x;
     if (cnt[x] > maxCnt) maxCnt = cnt[x];
     if (sum[maxCnt] == ) maxCnt --;
 }

 void dfs3(int u, int fr, int val) {
     update(c[u], val);
     for (int v : e[u]) {
         if (v == fr) continue;
         dfs3(v, u, val);
     }
 }

 void dfs2(int u, int fr) {
     for (int v : e[u]) {
         if (v == fr || v == son[u]) continue;
         dfs2(v, u), dfs3(v, u, -);
     }
     if (son[u]) dfs2(son[u], u);
     for (int v : e[u]) {
         if (v == fr || v == son[u]) continue;
         dfs3(v, u, );
     }
     update(c[u], );
     ans[u] = sum[maxCnt];
 }

 int main() {
     ios::sync_with_stdio(false);
     cin >> n;
     for (int i = ; i <= n; i ++)
         cin >> c[i];
     for (int u, v, i = ; i < n; i ++) {
         cin >> u >> v;
         e[u].push_back(v);
         e[v].push_back(u);
     }
     dfs1(, ), dfs2(, );
     for (int i = ; i <= n; i ++)
         cout << ans[i] << ' ';
     cout << endl;
     return ;
 }

长链剖分，选择深度大的儿子作为重儿子

O(1)继承重儿子信息，然后按深度合并轻儿子信息

因为每个节点被作为轻链节点只会被合并一次，所以O(n)

例题:http://codeforces.com/problemset/problem/1009/F

 /* 长链剖分,选择深度最大的儿子作为重儿子,用于合并以深度为下标的信息
  * 像 dsu 一样,直接继承重儿子信息,然后按深度暴力合并其他儿子信息
  * 时间复杂度考虑每个节点作为轻儿子里的节点被合并只会有一次,所以 O(n)
  * 另一种用法,可以 O(nlogn) 预处理后,O(1) 找到 k 级祖先
  */
 int n;
 int len[N], son[N], ans[N];
 vector <int> e[N];
 int tmp[N], *ptr, *f[N];
 void dfs(int u, int fr) {
     for (int v : e[u]) {
         if (v == fr) continue;
         dfs(v, u);
         if (len[v] > len[son[u]]) son[u] = v;
     }
     len[u] = len[son[u]] + ;
 }
 void dp(int u, int fr) {
     f[u][] = ;
     if (son[u]) {
         f[son[u]] = f[u] + ;
         dp(son[u], u);
         ans[u] = ans[son[u]] + ;
     }
     for (int v : e[u]) {
         if (v == son[u] || v == fr) continue;
         f[v] = ptr, ptr += len[v];
         dp(v, u);
         for (int j = ; j < len[v]; j ++) {
             f[u][j + ] += f[v][j];
             if ((f[u][j + ] > f[u][ans[u]]) || (f[u][j + ] == f[u][ans[u]] && j +  < ans[u]))
                 ans[u] = j + ;
         }
     }
     if (f[u][] >= f[u][ans[u]]) ans[u] = ;
 }
 int main() {
     in(n);
     for (int u, v, i = ; i < n; i ++) {
         in(u), in(v);
         e[u].push_back(v);
         e[v].push_back(u);
     }
     dfs(, );
     f[] = ptr = tmp, ptr += len[];
     dp(, );
     for (int i = ; i <= n; i ++)
         printf("%d\n", ans[i]);
     return ;
 }

区分几种算法(dsu，树链剖分，树分治)用途:

树链剖分分为重链剖分和长链剖分

重链剖分应用比较多也比较常见不再赘述

当然dsu虽然也是一种应用但还是拿出来提一下把

下面的树分治仅仅针对点分治

dsu，长链剖分，点分治

三种都是无修改的树上信息查询算法

dsu应用限制:

只能统计子树中所有点的信息，并且操作必须支持删除

所以无法维护链的信息

长链剖分应用限制:

因为一般用于基于深度的信息合并

所以无法维护子树全部信息，只能维护深度相关信息

所以对于有边权的树一般都没有办法

树分治应用限制：

多用来树上路径的统计计数

缺点是无法像上述两种算法O(1)继承某个儿子的信息

所以可维护的信息种类相对有限