dsu_on_tree

大佬博客：https://codeforces.com/blog/entry/44351
使用范围：常用来求子树的信息，比如，如果一棵树上每个节点都有一种颜色，求一个子树中颜色c的出现次数
复杂度分析：这个就是启发式合并，每一次合并都将小的集合合并到大的集合，每个元素的合并次数最多为$logn$次，看起来像是$n^2$的合并，实际复杂度只有$nlogn$，如果使用了stl容器(map等)， 那么复杂度就会变成$n(logn)^2$

题目链接：https://codeforces.com/contest/600/problem/E
题意：给定一棵树，每个节点有一种颜色，问每个子树中颜色出现次数最多的颜色数值之和。这是一个模板题。

第一种写法：
small to large(最简单的写法，$O(n(logn)^2)$ )
由于使用了map，复杂度多了一个log。这种写法很暴力，就直接将所有子节点的信息全部合并在了一个map里面，这种写法容易爆内存

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1e5+5;
vector<int>e[maxn];
unordered_map<int,int>mp[maxn];
map<int,LL>tp[maxn];
int col[maxn];
LL ans[maxn];
int n;
void dfs(int u,int fa)
{
    mp[u][col[u]]++;
    tp[u][mp[u][col[u]]]=col[u];
    for(auto &v:e[u]){
        if(v==fa) continue;
        dfs(v,u);
        if(mp[v].size()>mp[u].size()){//较小的往较大的合并
            swap(mp[u],mp[v]);
            swap(tp[u],tp[v]);
        }
        for(auto &it:mp[v]){
            tp[u][mp[u][it.first]]-=it.first;
            mp[u][it.first]+=it.second;
            tp[u][mp[u][it.first]]+=it.first;
        }
        mp[v].clear();//记得清空
        tp[v].clear();
    }
    ans[u]=tp[u].rbegin()->second;
}
int main()
{
    //freopen("in","r",stdin);
    //freopen("out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&col[i]);
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        e[u].push_back(v);
        e[v].push_back(u);
    }
    dfs(1,0);
    for(int i=1;i<=n;i++) printf("%lld ",ans[i]);
    return 0;
}

第二种写法：
heavy-light decomposition(轻重链分解？ 复杂度$O(nlogn)$)

主要思想就是优先访问轻儿子，后访问重儿子。在递归结束回到一个节点的时候，我们可以直接向下暴力计算轻儿子对答案的贡献，因为我们每次计算完答案之后，如果当前这个节点是轻儿子那么我们就会消除贡献，否则就保留，所以这里不需要再次统计重儿子对答案的贡献。

这种写法就是利用了树剖的性质，从根结点到任意结点的路径所经过的轻重链的个数必定都小于logn。所以在add函数中，每个节点最多出现$logn$次，所以总体复杂度也就只有$O(nlogn)$。

其中的keep表示的是是否需要消除影响，并且只有一个节点是其父节点的轻儿子时才会是keep=true，keep的默认值是false。

取消重儿子标记的原因是，这个标记只是表示对当前节点来说是否是重儿子，比如，如果一个节点有一个轻儿子child1和重儿子child2，对于轻儿子child1也有其自己的重儿子，如果没有取消掉child1下面的重儿子的标记，那么在我们用add函数统计所有轻儿子节点时会漏掉child1的重儿子的信息。

这种写法需要改变只有add函数

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1e5+5;
vector<int>e[maxn];
int n,maxx;
int col[maxn],cnt[maxn],sz[maxn],son[maxn];
LL sum[maxn],ans[maxn];
bool big[maxn];//是否是重儿子
void dfs1(int u,int fa)
{
    sz[u]=1;
    for(auto v:e[u]){
        if(v==fa) continue;
        dfs1(v,u);
        sz[u]+=sz[v];
        if(son[u]==-1||sz[v]>sz[son[u]])
            son[u]=v;
    }
}
void add(int u,int fa,int val)
{//只计算轻儿子的贡献
    sum[cnt[col[u]]]-=col[u];
    cnt[col[u]]+=val;
    sum[cnt[col[u]]]+=col[u];
    maxx=max(maxx,cnt[col[u]]);
    for(auto v:e[u]){
        if(v==fa||big[v]) continue;
        add(v,u,val);
    }
}
void dfs2(int u,int fa,bool keep)
{
    for(auto v:e[u]){
        if(v==fa||v==son[u]) continue;
        dfs2(v,u,false);//优先访问轻儿子，并且不保留贡献
    }
    if(son[u]!=-1){
        dfs2(son[u],u,true);
        big[son[u]]=true;//后访问重儿子，保留贡献
    }
    add(u,fa,1);//暴力递归下去统计答案
    ans[u]=sum[maxx];//计算答案
    if(son[u]!=-1) big[son[u]]=false;//对重儿子取消标记
    if(!keep) add(u,fa,-1),maxx=0; //当前节点是轻儿子，消除贡献
}
int main()
{
    //freopen("in","r",stdin);
    //freopen("out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&col[i]);
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        e[u].push_back(v);
        e[v].push_back(u);
    }
    memset(son,-1,sizeof son);
    dfs1(1,0);
    dfs2(1,0,false);
    printf("%lld",ans[1]);
    for(int i=2;i<=n;i++) printf(" %lld",ans[i]);
    return 0;
}

第三种写法：
这是CF上大佬的写法,复杂度也是$O(nlogn)$，但是貌似比第二种写法跑得快一些，写起来差不多。
这种写法是对第一种写法的改进吧，多了一个dfs序，这样写应该就是将方法二中递归计算的过程变成了迭代，减小了常数。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn=1e5+5;
vector<int>e[maxn];
int n,dfs_clock,maxx;
int st[maxn],ed[maxn],pre[maxn],col[maxn];
int sz[maxn],son[maxn],cnt[maxn];
LL sum[maxn],ans[maxn];
void dfs1(int u,int fa)
{
    st[u]=++dfs_clock;
    pre[dfs_clock]=u;//原节点编号
    sz[u]=1;
    for(auto v:e[u]){
        if(v==fa) continue;
        dfs1(v,u);
        sz[u]+=sz[v];
        if(son[u]==-1||sz[v]>sz[son[u]])
            son[u]=v;
    }
    ed[u]=dfs_clock;
}
void add(int u,int val)
{
    for(int i=st[u];i<=ed[u];i++){
        int tc=col[pre[i]];
        sum[cnt[tc]]-=tc;
        cnt[tc]+=val;
        sum[cnt[tc]]+=tc;
        maxx=max(maxx,cnt[tc]);
    }
}
void dfs2(int u,int fa,bool keep)
{
    for(auto v:e[u]){
        if(v==fa||v==son[u]) continue;
        dfs2(v,u,false);//优先访问轻儿子，并且不保留贡献
    }
    if(son[u]!=-1) dfs2(son[u],u,true);//后访问重儿子，保留贡献
    for(auto v:e[u]){
        if(v==fa||v==son[u]) continue;
        add(v,1);//根据dfs序统计答案
    }
    //计算当前节点u的贡献
    sum[cnt[col[u]]]-=col[u];
    cnt[col[u]]++;
    sum[cnt[col[u]]]+=col[u];
    maxx=max(maxx,cnt[col[u]]);

    ans[u]=sum[maxx];//记录答案

    if(!keep) add(u,-1),maxx=0;//轻儿子消除贡献
}
int main()
{
    //freopen("in","r",stdin);
    //freopen("out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&col[i]);
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        e[u].push_back(v);
        e[v].push_back(u);
    }
    memset(son,-1,sizeof son);
    dfs1(1,0);
    dfs2(1,0,false);
    printf("%lld",ans[1]);
    for(int i=2;i<=n;i++) printf(" %lld",ans[i]);
    return 0;
}