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 + 5;

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] = 1;
    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] == 0) 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, -1);
    }
    if (son[u]) dfs2(son[u], u);
    for (int v : e[u]) {
        if (v == fr || v == son[u]) continue;
        dfs3(v, u, 1);
    }
    update(c[u], 1);
    ans[u] = sum[maxCnt];
}

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

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

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]] + 1;
}
void dp(int u, int fr) {
    f[u][0] = 1;
    if (son[u]) {
        f[son[u]] = f[u] + 1;
        dp(son[u], u);
        ans[u] = ans[son[u]] + 1;
    }
    for (int v : e[u]) {
        if (v == son[u] || v == fr) continue;
        f[v] = ptr, ptr += len[v];
        dp(v, u);
        for (int j = 0; j < len[v]; j ++) {
            f[u][j + 1] += f[v][j];
            if ((f[u][j + 1] > f[u][ans[u]]) || (f[u][j + 1] == f[u][ans[u]] && j + 1 < ans[u]))
                ans[u] = j + 1;
        }
    }
    if (f[u][0] >= f[u][ans[u]]) ans[u] = 0;
}
int main() {
    in(n);
    for (int u, v, i = 1; i < n; i ++) {
        in(u), in(v);
        e[u].push_back(v);
        e[v].push_back(u);
    }
    dfs(1, 1);
    f[1] = ptr = tmp, ptr += len[1];
    dp(1, 1);
    for (int i = 1; i <= n; i ++)
        printf("%d
", ans[i]);
    return 0;
}

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

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

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

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

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

dsu，长链剖分，点分治

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

dsu应用限制:

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

所以无法维护链的信息

长链剖分应用限制:

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

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

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

树分治应用限制：

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

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

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