树上统计

解法很多，主要有主席树+dfs序 树上差分 树上启发式合并 线段树合并

---

1.主席树+dfs序

#include<bits/stdc++.h>
using namespace std;
#define FOR(i,x,y) for(int i=(x),i##_end_=(y);i<=i##_end_;i++)
#define DOR(i,x,y) for(int i=(x),i##_end_=(y);i>=i##_end_;i--)
#define M 500005
vector<int>edge[M];
int Root[M];
int Real[M],Lx[M],Rx[M],tot;
int Lson[M*20],Rson[M*20],Sum[20*M],tta;
struct Chairman_Tree{
    void insert(int l,int r,int x,int old,int &tid){
        tid=++tta;
        Lson[tid]=Lson[old];
        Rson[tid]=Rson[old];
        Sum[tid]=Sum[old]+1;
        int mid=(l+r)>>1;
        if(l==r)return;
        if(mid>=x)insert(l,mid,x,Lson[old],Lson[tid]);
        else insert(mid+1,r,x,Rson[old],Rson[tid]);
    }
    int query(int l,int r,int old,int tid,int x){
        if(l>r)return 0;
        if(l==r)return Sum[tid]-Sum[old];
        int mid=(l+r)>>1;
        if(mid>=x)return query(l,mid,Lson[old],Lson[tid],x);
        else return query(mid+1,r,Rson[old],Rson[tid],x);
    }
}Tree;
void dfs(int x,int f){
    Real[++tot]=x;
    Lx[x]=tot;
    for(int i=0;i<(int)edge[x].size();i++){
        int y=edge[x][i];
        if(y==f)continue;
        dfs(y,x);
    }
    Rx[x]=tot;
}
int Val[M];
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    FOR(i,1,n)scanf("%d",&Val[i]);
    FOR(i,1,n-1){
        int x,y;
        scanf("%d%d",&x,&y);
        edge[x].push_back(y);
        edge[y].push_back(x);
    }
    dfs(1,0);
    FOR(i,1,n)Tree.insert(1,n,Val[Real[i]],Root[i-1],Root[i]);
    FOR(i,1,m){
        int x,z;
        scanf("%d%d",&x,&z);
        printf("%d\n",Tree.query(1,n,Root[Lx[x]-1],Root[Rx[x]],z));
    }
    return 0;
}

线段树合并+可持久化

内存会比较大，大约为$2*logn*n$

#include<bits/stdc++.h>
using namespace std;
#define FOR(i,x,y) for(int i=(x),i##_end_=(y);i<=i##_end_;i++)
#define DOR(i,x,y) for(int i=(x),i##_end_=(y);i>=i##_end_;i--)
#define M 500005

vector<int>edge[M];
int Root[M];
int A[M];

struct Segment_Tree{
    int tot;
    int Lson[M*40],Rson[M*40],Sum[M*40];
    void insert(int l,int r,int x,int &tid){
        tid=++tot;
        int mid=(l+r)>>1;
        Sum[tid]=1;
        if(l==r)return;
        if(mid>=x)insert(l,mid,x,Lson[tid]);
        else insert(mid+1,r,x,Rson[tid]);
    }
    int merge(int x,int y){
        if(!x||!y)return x|y;
        int z=++tot;
        Sum[z]=Sum[x]+Sum[y];
        Lson[z]=merge(Lson[x],Lson[y]);
        Rson[z]=merge(Rson[x],Rson[y]);
        return z;
    }
    int query(int l,int r,int tid,int x){
        int mid=(l+r)>>1;
        if(l==r)return Sum[tid];
        if(mid>=x)return query(l,mid,Lson[tid],x);
        else return query(mid+1,r,Rson[tid],x);
    }
}Tree;
void dfs(int x,int f){
    for(int i=0;i<(int)edge[x].size();i++){
        int y=edge[x][i];
        if(y==f)continue;
        dfs(y,x);
        Root[x]=Tree.merge(Root[x],Root[y]);
    }
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    FOR(i,1,n){
        scanf("%d",&A[i]);
        Tree.insert(1,n,A[i],Root[i]);
    }
    FOR(i,1,n-1){
        int x,y;
        scanf("%d%d",&x,&y);
        edge[x].push_back(y);
        edge[y].push_back(x);
    }
    dfs(1,0);
    FOR(i,1,m){
        int x,z;
        scanf("%d%d",&x,&z);
        printf("%d ",Tree.query(1,n,Root[x],z));
    }
    return 0;
}

树上差分

O(n)复杂度

#include<bits/stdc++.h>
using namespace std;
#define FOR(i,x,y) for(int i=(x),i##_end_=(y);i<=i##_end_;i++)
#define DOR(i,x,y) for(int i=(x),i##_end_=(y);i>=i##_end_;i--)
#define M 500005

int To[M<<1],nxt[M<<1],head[M],ttaE;
void addedge(int a,int b){nxt[++ttaE]=head[a];head[a]=ttaE;To[ttaE]=b;}
#define LFOR(i,x) for(int i=head[x];~i;i=nxt[i])
int Val[M],ans[M],Cnt[M],B[M];
struct node{int id,y;};
vector<node>Q[M];

void dfs(int x,int f){
    for(int i=0;i<(int)Q[x].size();i++)
        ans[Q[x][i].id]-=Cnt[Q[x][i].y];
    Cnt[Val[x]]++;
    LFOR(i,x){
        int y=To[i];
        if(y==f)continue;
        dfs(y,x);
    }
    for(int i=0;i<(int)Q[x].size();i++)
        ans[Q[x][i].id]+=Cnt[Q[x][i].y];
}

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    FOR(i,1,n)head[i]=-1;
    FOR(i,1,n)scanf("%d",&Val[i]),B[i]=Val[i];

    FOR(i,1,n-1){
        int x,y;
        scanf("%d%d",&x,&y);
        addedge(x,y);
        addedge(y,x);
    }
    FOR(i,1,m){
        int x,y;
        scanf("%d%d",&x,&y);
        Q[x].push_back((node){i,y});
    }
    dfs(1,0);
    FOR(i,1,m)printf("%d ",ans[i]);
    return 0;
}

DSU(树上启发式合并)

#include<bits/stdc++.h>
using namespace std;
#define FOR(i,x,y) for(int i=(x),i##_end_=(y);i<=i##_end_;i++)
#define DOR(i,x,y) for(int i=(x),i##_end_=(y);i>=i##_end_;i--)
#define M 500005

int To[M<<1],nxt[M<<1],head[M],ttaE;
void addedge(int a,int b){nxt[++ttaE]=head[a];head[a]=ttaE;To[ttaE]=b;}
#define LFOR(i,x) for(int i=head[x];~i;i=nxt[i])

struct node{int id,k;};
vector<node>Q[M];

int Val[M],ans[M];
int fa[M],sz[M],son[M];
int Lx[M],Rx[M],dfn[M],tot;
void dfs(int x,int f){
    fa[x]=f,sz[x]=1,son[x]=-1;
    Lx[x]=++tot;
    dfn[tot]=x;
    LFOR(i,x){
        int y=To[i];
        if(y==f)continue;
        dfs(y,x);
        sz[x]+=sz[y];
        if(!~son[x]||sz[son[x]]<sz[y])son[x]=y;
    }
    Rx[x]=tot;
}

map<int,int>Cnt;
void add(int x){
    FOR(i,Lx[x],Rx[x]){
        Cnt[Val[dfn[i]]]++;
    }
}
void del(int x){
    FOR(i,Lx[x],Rx[x]){
        Cnt[Val[dfn[i]]]--;
    }
}
void Solve(int x){
    LFOR(i,x){
        int y=To[i];
        if(y==son[x]||y==fa[x])continue;
        Solve(y);del(y);
    }
    if(~son[x])Solve(son[x]);
    LFOR(i,x){
        int y=To[i];
        if(y==son[x]||y==fa[x])continue;
        add(y);
    }
    Cnt[Val[x]]++;
    for(int i=0;i<(int)Q[x].size();i++)
        ans[Q[x][i].id]=Cnt[Q[x][i].k];
}

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    FOR(i,1,n)scanf("%d",&Val[i]);
    FOR(i,1,n)head[i]=-1;
    FOR(i,1,n-1){
        int x,y;
        scanf("%d%d",&x,&y);
        addedge(x,y);
        addedge(y,x);
    }
    FOR(i,1,m){
        int x,y;
        scanf("%d%d",&x,&y);
        Q[x].push_back((node){i,y});
    }
    dfs(1,0);
    Solve(1);
    FOR(i,1,m)printf("%d ",ans[i]);
    return 0;
} 

小结：
可以发现
树上差分的想法简单，复杂度小，空间复杂度小，应用范围也广
主席树复杂度一般，空间复杂度大，但思考量小
线段树合并类似于主席树，但空间复杂度要更大些
DSU的复杂度也为nlogn，在代码上会略复杂些，但空间复杂度一般较小