树链剖分|树上启发式合并

树链剖分

分为重链剖分和长链剖分以及其他奇怪的剖分。以重剖为主。

重链剖分

将树上问题重链剖分为序列问题（经常是 DFS 序）然后用数据结构（经常是线段树）维护。

剖分部分

定义：

重儿子：对于一个点，其儿子中，子树最大的那个；
重边：父亲到重儿子的连边；
轻儿子：除了重儿子以外的儿子；
轻边：父亲到轻儿子的连边。

证明一个东西：一条链上（不是路径，虽然差不多，路径就是两条链拼起来）至多有 $\log n$ 条轻边。

很显然，每次若是走轻边，子树大小都至少会减少一半，所以至多走 $\log n$ 次就到底了。

于是我们即使暴力维护轻边的复杂度都是 $O (F (n) \log n)$ 的， $F (n)$ 是数据结构单点操作复杂度。

而由于重边在儿子中的唯一性，所以所有的重边形成了若干条链，不妨称之重链。

一条链上包含多条重链。由于轻重边的交替排布，重链的数量级也是 $\log n$ 的。考虑到大部分数据结构维护的是下标连续的区间，于是这里有一个小 trick，DFS 求 dfn 时，优先走重边，这样重链上的下标就连续了，所以我们只要做一次数据结构的区间操作即可维护重边上的信息，记 $t o p (u)$ 为包含 $u$ 的重链的链头，则每次跳 $u \to f a (t o p (u))$ 即可一次跳过一条重链加一条轻边，时间复杂度 $O (F^{'} (n) \log n)$ ， $F^{'} (n)$ 为数据结构区间操作复杂度，对于线段树这种的， $F^{'} (n) ≐ F (n)$ 。

综上对于一条链的操作，复杂度就为 $O (F (n) \log n)$ 。

例题：

给你一棵带边权树，支持下列操作：

查询子树和

查询 $u, v$ 路径和

修改子树边权

修改路径边权

先 DFS 出 dfn，然后操作 1、3 对应了一段连续的区间，直接线段树区间操作即可；操作 2、4 首先将路径拆成两条链 $(u, lca), (lca, v)$ ，然后分别剖即可。时间复杂度分别为 $O (\log n), O (\log^{2} n)$ 。

实现

第一遍 DFS 求出以下信息：

$d e p (u)$ ： $u$ 的深度；
$s i z (u)$ ： $u$ 子树大小；
$s o n (u)$ ： $u$ 的重儿子；
$f a (u)$ ： $u$ 的父亲。

void dfs1(int u,int Fa){
    dep[u]=dep[Fa]+1;
    fa[u]=Fa;
    int mxson,mxsiz=0;
    for(edge v:e[u]){
        if(v.v!=fa){
            dfs1(v.v,u);
            siz[u]+=siz[v.v];
            if(siz[v.v]>mxsiz)
                mxsiz=siz[v.v],mxson=v.v;
        }
    }
    son[u]=mxson;
}

第二遍 DFS 求出以下信息：

$t o p (u)$ ：包含 $u$ 的重链链头；
$d f n (u)$ ： $u$ 的 dfn（ $r d f n (u)$ 为回溯时 $u$ 的 dfn）；
$i d x (u)$ ： $u$ 的 dfn 逆向索引。

void dfs2(int u,int t){
    top[u]=t;
    dfn[u]=++dfncnt;
    idx[dfncnt]=u;
    if(top[son[u]]!=t) dfs2(son[u],son[u]);
    else dfs2(son[u],t);
    for(edge v:e[u]){
        if(v.v!=fa[u]&&v.v!=son[u]){
            dfs2(v.v,v.v); // 轻儿子肯定不在 u 的重链上
        }
    }
    // rdfn[u]=dfncnt;
}

修改路径：

void modify_chain(int u,int v,int x){
    int fu=u,fv=v;
    while(top[fu]!=top[fv]){
        if(dep[top[fu]]<dep[top[fv]]) swap(fu,fv); 
        modify(1,1,n,dfn[top[fu]],dfn[fu],x);
        fu=fa[top[fu]]; // 每次选深的跳直到到同一重链上
    }
    if(dep[fu]>dep[fv]) swap(fu,fv);
    modify(1,1,dfn[fu],dfn[fv],x);
}

查询路径：

int query_chain(int u,int v,int x){
    int fu=u,fv=v,res=0;
    while(top[fu]!=top[fv]){
        if(dep[top[fu]]<dep[top[fv]]) swap(fu,fv); 
        res+=query(1,1,n,dfn[top[fu]],dfn[fu],x);
        fu=fa[top[fu]]; // 每次选深的跳直到到同一重链上
    }
    if(dep[fu]>dep[fv]) swap(fu,fv);
    res+=query(1,1,dfn[fu],dfn[fv],x);
    return res;
}

特殊的，如果信息在点上，则可以把信息转移到边 $(u, f a (u))$ 上。

长链剖分

忘了，但是很迪奥。

树上启发式合并（DSU on tree）

思想

借用了重剖的思想。分三步：

递归走轻儿子统计子树答案（不对答案影响）
走重儿子统计答案并把答案留在每个重儿子上
再走轻儿子合并答案

考虑复杂度，由重剖中的证明，轻儿子至多走 $\log n$ 个，重儿子只走一遍，总复杂度 $O (n \log n)$ 。

容易知道，其限制是不能带修，只能处理子树问题。

实现

void dfs1(int u,int Fa);        // 重剖
void add(int u,int Fa);         // 统计子树答案
void del(int u,int Fa);         // 消除影响
int getans();
void dfs(int u,int Fa,int type){// type -> 边的类型
    for(auto v:e[u]){
        if(v.v!=Fa&&v.v!=son[u]){
            dfs(v,u,0);
        }
    }
    if(son[u]) dfs(son[u],u,1);
    for(auto v:e[u]){
        if(v.v!=Fa&&v.v!=son[u]){
            add(v.v,u);         // 统计轻儿子子树答案
        }
    }
    add(u);                     // 处理重链答案
    ans[u]=getans();            // 保存子树答案
    if(!type) del(u,Fa);        // 如果是轻儿子消去影响
}

例题 1：CF600E Lomsat gelral

给一棵树，每个节点有一种颜色 $c_{u}$ ，设一个节点的主导颜色集合 $P_{u}$ 为其子树内最多的颜色，对于每个节点求 $\sum_{x \in P_{u}} x$ 。
$n \leq 10^{5}$

开一个桶 $c n t_{c}$ 表示颜色 $c$ 出现次数，再开一个桶 $p_{x}$ 表示出现次数为 $x$ 的颜色编号和，然后可写出 add 和 del。时间复杂度 $O (n \log n)$ 。

这里有一个小 trick，就是如果统计子树答案与子树结构无关，则可以根据子树内 dfn 连续而直接遍历 $[d f n (u), r d f n (u)]$ 统计答案即可。(PS：但还是不建议这样用，有时候可能莫名 WA 掉)

int mxtcnt;
void add(int u,int Fa){
    pcnt[cnt[c[u]]]-=c[u];
    cnt[c[u]]++;
    pcnt[cnt[c[u]]]+=c[u];
    if(cnt[c[u]]>mxtcnt) mxtcnt=cnt[c[u]];
}
void del(int u){
    pcnt[cnt[c[u]]]-=c[u];
    cnt[c[u]]--;
    pcnt[cnt[c[u]]]+=c[u];
    while(!pcnt[mxtcnt]) mxtcnt--;
}
int getans(){
    return pcnt[mxtcnt];
}
void dfs(int u,int Fa,int type){
    for(int v:e[u]){
        if(v!=Fa&&v!=son[u]){
            dfs(v,u,0);
        }
    }
    if(son[u]) dfs(son[u],u,1);
    for(int v:e[u]){
        if(v!=Fa&&v!=son[u]){
            for(int i=dfn[v];i<=rdfn[v];i++){
                add(idx[i]);
            } 
        }
    }
    add(u);
    ans[u]=getans();
    if(!type){
        for(int i=dfn[u];i<=rdfn[u];i++){
            del(idx[i]);
        }
    }
}

例题 2：CF570D Tree Requests

给一棵树，每个点有一个字母 $c_{u}$ ，定义深度为到 1 的距离， $m$ 次询问 $u$ 子树内深度为 $x$ 的点上的字母是否能重组变成回文串。
$n \leq 5 \times 10^{5}$

注意到回文串等价于至多存在一个字母的数量为奇数。我们可以直接用异或来代替，并用 __builtin_popcount(cnt[dep[x]])<=1 来判断是否合法。其他同理。

code

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+3;
int n,c[maxn],dep[maxn],fa[maxn],son[maxn],siz[maxn],dfn[maxn],rdfn[maxn],idx[maxn],dfncnt;
vector<int>e[maxn];
struct pi{
    int first;
    int second;
};
vector<pi>Q[maxn];
int ans[maxn],cnt[maxn];
void dfs1(int u,int Fa){
    idx[dfncnt]=u;
    dep[u]=dep[Fa]+1;
    fa[u]=Fa;
    siz[u]=1;
    int mxson=0,mxsiz=0;
    for(int v:e[u]){
        if(v!=Fa){
            dfs1(v,u);
            siz[u]+=siz[v];
            if(siz[v]>mxsiz)
                mxsiz=siz[v],mxson=v;
        }
    }
    son[u]=mxson;
    rdfn[u]=dfncnt;
}
int json;
void add(int u){
    cnt[dep[u]]^=(1<<c[u]);
}
void del(int u){
    cnt[dep[u]]^=(1<<c[u]);
}
void dfs(int u,int Fa,int type){
    for(int v:e[u]){
        if(v!=Fa&&v!=son[u]){
            dfs(v,u,0);
        }
    }
    if(son[u]) dfs(son[u],u,1);
    for(int v:e[u]){
        if(v!=Fa&&v!=son[u]){
            for(int i=dfn[v];i<=rdfn[v];i++){
                add(idx[i]);
            } 
        }
    }
    add(u);
    for(auto i:Q[u]){
        if(__builtin_popcount(cnt[i.first])<=1) ans[i.second]=1;
        else ans[i.second]=0;
    }
    if(!type){
        for(int i=dfn[u];i<=rdfn[u];i++) del(idx[i]);
    }
}
signed main(){
    int m;
    ios::sync_with_stdio(0);
    cin>>n>>m;
    for(int i=2,u;i<=n;i++){
        cin>>u;
        e[i].emplace_back(u);
        e[u].emplace_back(i);
    }
    for(int i=1;i<=n;i++){
        char ch;
        cin>>ch;
        c[i]=ch-'a';
    }
    for(int i=1,a,b;i<=m;i++){
        cin>>a>>b;
        Q[a].push_back({b,i});
    }
    dfs1(1,0);
    dfs(1,0,0);
    for(int i=1;i<=m;i++){
        if(ans[i]) puts("Yes");
        else puts("No");
    }
    return 0;
}

例题 3：CF246E Blood Cousins Return

给一个森林，每个点有一个颜色 $c_{u}$ ， $m$ 次询问 $u$ 子树内距离 $u$ 为 $k$ 的点的颜色种类数。
$n \leq 10^{5}$

同理，开一个桶 cnt[k][c] 记录当前子树内深度为 $k$ 颜色 $c$ 的数量，然后跑 DSU 即可，注意我们这个数组是开不下的，需要开 map，所以时间复杂度 $O (n \log^{2} n)$ 。

code

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e5+3;
int n,c[maxn],dep[maxn],fa[maxn],son[maxn],siz[maxn];
vector<int>e[maxn];
map<string,int> mp;
int ncnt;
struct pi{
    int first;
    int second;
};
vector<pi>Q[maxn];
int ans[maxn];
map<int,int>cnt[maxn];
void dfs1(int u,int Fa){
    dep[u]=dep[Fa]+1;
    fa[u]=Fa;
    siz[u]=1;
    int mxson=0,mxsiz=0;
    for(int v:e[u]){
        if(v!=Fa){
            dfs1(v,u);
            siz[u]+=siz[v];
            if(siz[v]>mxsiz)
                mxsiz=siz[v],mxson=v;
        }
    }
    son[u]=mxson;
}
int json;
int mxtcnt[maxn];
void add(int u){
    if(!cnt[dep[u]][c[u]]) mxtcnt[dep[u]]++;
    cnt[dep[u]][c[u]]++;
    for(int v:e[u]){
        if(v!=fa[u]&&v!=json) add(v);
    }
}
void del(int u){
    cnt[dep[u]][c[u]]--;
    if(!cnt[dep[u]][c[u]]) mxtcnt[dep[u]]--;
    for(int v:e[u]){
        if(v!=fa[u]) del(v);
    }
}
void dfs(int u,int Fa,int type){
    for(int v:e[u]){
        if(v!=Fa&&v!=son[u]){
            dfs(v,u,0);
        }
    }
    if(son[u]) dfs(son[u],u,1),json=son[u];
    add(u);json=0;
    for(auto i:Q[u]){
        ans[i.second]=mxtcnt[dep[u]+i.first];
    }
    if(!type){
        del(u);
    }
}
vector<int>root;
signed main(){
    int m;
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin>>n;
    for(int i=1,u;i<=n;i++){
        string ch;
        cin>>ch>>u;
        if(!mp[ch]) c[i]=mp[ch]=++ncnt;
        else c[i]=mp[ch];
        e[i].emplace_back(u);
        e[u].emplace_back(i);
        // if(!u) root.emplace_back(i);
    }
    cin>>m;
    for(int i=1,a,b;i<=m;i++){
        cin>>a>>b;
        Q[a].push_back({b,i});
    }
    dep[0]=-1;dfs1(0,0),dfs(0,0,0);
    
    for(int i=1;i<=m;i++){
        cout<<ans[i]<<" \n";
    }
    return 0;
}