dsu on tree题表

dsu on tree，又名树上启发式合并、重链剖分，是一类十分实用的trick，它常常可以作为一些正解的替代算法：

1.DFS序+线段树/主席树/线段树合并

2.对DFS序分块的树上莫队

3.长链剖分（但复杂度会多一个log）

4.点分治（通常可以做有根树的点分治）

重链剖分的概念，用一个DFS找到每个点最大的一个儿子，作为它的重儿子，并将它标记。则从上到下一段连续的标记点就成为一条重链。

重链剖分有一个常用的性质：每个点到根的路径上，至多经过$O(log n)$条重链。点分治、树链剖分都用到了这个性质。

dsu on tree 是一个优化后的暴力，主要优化的地方在于它先递归轻子树并消除影响，后递归重子树并保留影响。之后再计算该节点需要的信息。

它可以解决大部分无修改子树查询问题，需要问题满足以下几个条件：

1.有一个树上的$O(n^2)$暴力算法。

2.从轻子树合并上来的复杂度是线性的。

3.从重子树合并上来的复杂度是$O(1)$的。

4.可以在O(子树大小)时间内清空递归后的数组（也就是线性撤销所有影响）

dsu on tree的流程：

1.递归到所有轻儿子并消除影响。

2.递归到重儿子并保留影响。

3.递归所有轻儿子计算子树内除重子树之外的点对当前点答案的影响。

4.若此点不是父亲的重儿子则消除子树内所有影响（即将数组清空）。

另外，dsu on tree的题，只要使用的暴力数组是以深度为下标的，几乎都可以被长链剖分替代且复杂度少一个log。如下面的例2,3。

例一：[CF600E]询问每棵子树中出现次数最多的颜色（可能不只一个）的编号和。

首先考虑暴力算法，对每个点x DFS下去，得到一个计数器数组co[i]表示x的子树内颜色i的点的个数，同时维护x的答案。

然后重链剖分，按流程做即可，具体模板见代码。

#include<cstdio>
#include<algorithm>
#include<iostream>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
#define For(i,x) for (int i=h[x],k; i; i=nxt[i])
typedef long long ll;
using namespace std;

const int N=1000010;
int n,u,v,cnt,tot[N],mx,col[N],sz[N],son[N],h[N],to[N],nxt[N];
ll ans[N],sm;
bool skip[N];

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

void get(int x,int fa){
    sz[x]=1;
    For(i,x) if ((k=to[i])!=fa){
        get(k,x); sz[x]+=sz[k];
        if (sz[k]>sz[son[x]]) son[x]=k;
    }
}

void dfs(int x,int fa,int op){
    tot[col[x]]+=op;
    if (op>0 && tot[col[x]]>=mx){
        if (tot[col[x]]>mx) sm=0,mx=tot[col[x]];
        sm+=col[x];
    }
    For(i,x) if ((k=to[i])!=fa && !skip[k]) dfs(k,x,op);
}

void work(int x,int fa,bool cl){
    For(i,x) if ((k=to[i])!=fa && k!=son[x]) work(k,x,1);
    if (son[x]) work(son[x],x,0),skip[son[x]]=1;
    dfs(x,fa,1); ans[x]=sm; skip[son[x]]=0;
    if (cl) dfs(x,fa,-1),mx=sm=0;
}

int main(){
    scanf("%d",&n);
    rep(i,1,n) scanf("%d",&col[i]);
    rep(i,2,n) scanf("%d%d",&u,&v),add(u,v),add(v,u);
    get(1,0); work(1,0,0);
    rep(i,1,n) cout<<ans[i]<<' ';
    return 0;
}

例二：[CF570D]一棵树，询问某棵子树指定深度的点能否构成回文。

用二进制记录每个深度的每个字母出现次数的奇偶性即可。

#include<cstdio>
#include<vector>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
#define For(i,x) for (int i=h[x],k; i; i=nxt[i])
using namespace std;

const int N=1000010;
char s[N];
int n,m,x,y,cnt,skip,a[N],d[N],ans[N],fa[N],sz[N],son[N],to[N],nxt[N],h[N];
struct P{ int x,y; };
vector<P>ve[N];

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

void dfs(int x){
    d[x]=d[fa[x]]+1; sz[x]=1;
    For(i,x){
        dfs(k=to[i]); sz[x]+=sz[k];
        if (sz[k]>sz[son[x]]) son[x]=k;
    }
}

void get(int x){
    a[d[x]]^=1<<(s[x]-'a');
    For(i,x) if ((k=to[i])!=skip) get(k);
}

void work(int x,int op){
    For(i,x) if ((k=to[i])!=son[x]) work(k,1);
    if (son[x]) work(son[x],0),skip=son[x];
    get(x); skip=0; int ed=ve[x].size()-1;
    rep(i,0,ed) ans[ve[x][i].x]=__builtin_popcount(a[ve[x][i].y])<=1;
    if (op) get(x);
}

int main(){
    freopen("570D.in","r",stdin);
    freopen("570D.out","w",stdout);
    scanf("%d%d",&n,&m);
    rep(i,2,n) scanf("%d",&fa[i]),add(fa[i],i);
    rep(i,1,n) scanf(" %c",&s[i]);
    rep(i,1,m) scanf("%d%d",&x,&y),ve[x].push_back((P){i,y});
    dfs(1); work(1,1);
    rep(i,1,m) if (ans[i]) puts("Yes"); else puts("No");
    return 0;
}

例三：

[CF246E]一个森林，求k级后代中多少种不同的权值。

[CF208E]给出一个森林，求和一个点有相同k级祖先的点有多少。

第二个问题倍增找到k级祖先后就是弱化版的第一个问题了。

与例二类似，对每个深度维护一个set记录出现过的权值数目。

注意由于流程的最后一步是清空整个数组，所以删除的时候不需要考虑记录次数的问题。

#include<set>
#include<map>
#include<string>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<iostream>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
#define For(i,x) for (int i=h[x],k; i; i=nxt[i])
using namespace std;

const int N=200010;
string s;
map<string,int>mp;
int n,Q,x,y,tot,skip,cnt,rts,id[N],fa[N],rt[N],ans[N],sz[N];
int son[N],d[N],h[N],to[N<<1],nxt[N<<1];
set<int>S[N];
struct P{ int x,y; };
vector<P>ve[N];
void add(int u,int v){ to[++cnt]=v; nxt[cnt]=h[u]; h[u]=cnt; }

void dfs(int x){
    d[x]=d[fa[x]]+1; sz[x]=1;
    For(i,x){
        dfs(k=to[i]); sz[x]+=sz[k];
        if (sz[k]>sz[son[x]]) son[x]=k;
    }
}

void get(int x,int op){
    if (op) S[d[x]].insert(id[x]); else S[d[x]].erase(id[x]);
    For(i,x) if ((k=to[i])!=skip) get(k,op);
}

void work(int x,int op){
    For(i,x) if ((k=to[i])!=son[x]) work(k,1);
    if (son[x]) work(son[x],0),skip=son[x];
    get(x,1); skip=0; int ed=ve[x].size()-1;
    rep(i,0,ed) ans[ve[x][i].x]=S[d[x]+ve[x][i].y].size();
    if (op) get(x,0);
}

int main(){
    scanf("%d",&n);
    rep(i,1,n){
        cin>>s>>fa[i];
        if (mp.find(s)!=mp.end()) id[i]=mp[s]; else mp[s]=id[i]=++tot;
        if (!fa[i]) rt[++rts]=i; else add(fa[i],i);
    }
    scanf("%d",&Q);
    rep(i,1,Q) scanf("%d%d",&x,&y),ve[x].push_back((P){i,y});
    rep(i,1,rts) dfs(rt[i]),work(rt[i],1);
    rep(i,1,Q) printf("%d
",ans[i]);
    return 0;
}

例四：[CF741D]一棵有根树，边上有字母a~v，求每个子树中最长的边，满足这个边上的所有字母重排后可以构成回文。

很容易想到点分治，但由于是有根树，所以点分治是做不了的。

先对没给点记录w[x]表示x到根的路径的各个字母出现奇偶性，然后p[S]记录满足w[x]=S的所有点x的最大深度。

类似点分治，一棵子树一棵子树地处理，每次先对子树内每个点查找之前子树中是否有能与它拼成回文串的点与它的最大深度，再更新p[]。

注意查找和更新不能同时进行，要整棵子树都查询完毕之后再进行更新操作。注意查找与更新当前子树的根。

#include<cstdio>
#include<algorithm>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
#define For(i,x) for (int i=h[x],k; i; i=nxt[i])
using namespace std;

const int N=1000010,inf=1e9;
char s[N];
int n,cnt,d[N],fa[N],ans[N],w[N],sz[N],son[N],p[1<<23],h[N],to[N<<1],nxt[N<<1];
void add(int u,int v){ to[++cnt]=v; nxt[cnt]=h[u]; h[u]=cnt; }

void dfs(int x){
    d[x]=d[fa[x]]+1; sz[x]=1;
    For(i,x){
        k=to[i]; w[k]=w[x]^(1<<(s[k]-'a')); dfs(k); sz[x]+=sz[k];
        if (sz[k]>sz[son[x]]) son[x]=k;
    }
}

void get(int rt,int x){
    ans[rt]=max(ans[rt],p[w[x]]+d[x]-2*d[rt]);
    rep(i,0,21) ans[rt]=max(ans[rt],p[w[x]^(1<<i)]+d[x]-2*d[rt]);
    For(i,x) get(rt,k=to[i]);
}

void get2(int x){ p[w[x]]=max(p[w[x]],d[x]); For(i,x) get2(k=to[i]); }

void del(int x){ p[w[x]]=-inf; For(i,x) del(k=to[i]); }

void work(int x,int op){
    For(i,x) if ((k=to[i])!=son[x]) work(k,1),ans[x]=max(ans[x],ans[k]);
    if (son[x]) work(son[x],0),ans[x]=max(ans[x],ans[son[x]]);
    For(i,x) if ((k=to[i])!=son[x]) get(x,k),get2(k);
    ans[x]=max(ans[x],p[w[x]]-d[x]);
    rep(i,0,21) ans[x]=max(ans[x],p[w[x]^(1<<i)]-d[x]);
    p[w[x]]=max(p[w[x]],d[x]);
    if (op) del(x);
}

int main(){
    freopen("741D.in","r",stdin);
    freopen("741D.out","w",stdout);
    scanf("%d",&n);
    rep(i,2,n) scanf("%d %c",&fa[i],&s[i]),add(fa[i],i);
    rep(i,0,(1<<22)-1) p[i]=-inf;
    dfs(1); work(1,0);
    rep(i,1,n) printf("%d ",ans[i]);
    return 0;
}