[模板]树链剖分讲解与模板

树链剖分的思想比较神奇
它的思想是：把一棵树拆成若干个不相交的链，然后用一些数据结构去维护这些链

重儿子：该节点的子树中,节点个数最多的子树的根节点(也就是和该节点相连的点)，即为该节点的重儿子
重边：连接该节点与它的重儿子的边
重链：由一系列重边相连得到的链
轻链：由一系列非重边相连得到的链

变量声明：
son重儿子;
tot子树的大小;
top该点所在重链头;
dfn遍历到的顺序(新的编号);
id：dfs序中原来的点对应的位置;

step1

简单的dfs更新deep son fa

void dfs1(int x,int f,int depth)
{
    fa[x]=f;
    deep[x]=depth;
    tot[x]=1;//错0 
    int maxnow=-1;
    for (int i=head[x]; i!=0; i=edge[i].next)
    {
        int to=edge[i].to;
        if (to!=f)
        {
            dfs1(to,x,depth+1);
            tot[x]+=tot[to];//回溯的时候更新tot和son 
            if (tot[to]>maxnow)
            {
                maxnow=tot[to];
                son[x]=to;
            }
        }
    }
}

step2

此处的dfs用来更新dfs序和top

int cnt=0;//遍历时间计数器 
void dfs2(int x,int tp)
{//因为对于轻儿子来说,top[u]=u，对于重儿子来说，如果son[v]!=-1,那么top[v]=top[son[v]]  
    dfn[x]=++cnt;
    id[cnt]=x;//和dfn互为反数组 
    top[x]=tp;
    if (!son[x]) return;//先访问重孩子，再访问轻孩子 
    dfs2(son[x],tp);

    for (int i=head[x]; i!=0; i=edge[i].next)
    {
        int to=edge[i].to;
        if (to!=fa[x] && to!=son[x])//
            dfs2(to,to);
    }
}

step3

以下为线段树操作
把重新编号完的每个节点映射到线段树上

void pushup(int rt)
{
    sum[rt]=(sum[rt<<1]+sum[rt<<1|1])%mod;
}

void pushdown(int rt,int ln,int rn)
{
    if (add[rt])
    {
        add[rt<<1]=(add[rt<<1]+add[rt])%mod;
        add[rt<<1|1]=(add[rt<<1|1]+add[rt])%mod;
        sum[rt<<1]=(sum[rt<<1]+add[rt]*ln)%mod;
        sum[rt<<1|1]=(sum[rt<<1|1]+add[rt]*rn)%mod;
        add[rt]=0;
    }
}

void build_tree(int rt,int l,int r)
{
    if (l==r)
    {
        sum[rt]=a[id[l]];//id里面保存dfs对应的本来的数字 
        return;//dfs序把路径转化成区间 
    }
    int mid=(l+r)>>1;
    build_tree(rt<<1,l,mid);
    build_tree(rt<<1|1,mid+1,r);
    pushup(rt);
}

void change(int L,int R,int C,int l,int r,int rt)
{
    if (L<=l && r<=R)
    {
        add[rt]=(add[rt]+C)%mod;
        sum[rt]=(sum[rt]+C*(r-l+1))%mod;
        return;
    }
    int mid=(l+r)>>1;
    pushdown(rt,mid-l+1,r-mid);
    if (L<=mid) change(L,R,C,l,mid,rt<<1);
    if (R>mid) change(L,R,C,mid+1,r,rt<<1|1);
    pushup(rt);
}

int ques(int L,int R,int l,int r,int rt)
{
    if (L<=l && r<=R) return sum[rt]%mod;
    int mid=(l+r)>>1;
    int ans=0;
    pushdown(rt,mid-l+1,r-mid);
    if (L<=mid) ans=(ans+ques(L,R,l,mid,rt<<1))%mod;
    if (R>mid) ans=(ans+ques(L,R,mid+1,r,rt<<1|1))%mod;
    return ans;
    pushup(rt);
}

step4

轻重连剖分实际上就是一种倍增算法
首先对于x和y两个节点，首先让他们两个分别倍增跳到最近的重链头上，（重链头不重合）两个重链头在进行LCA
用线段树来维护

void tree_add(int x,int y,int k)//x和y到重链头的路径加k 
{
    k%=mod;
    while (top[x]!=top[y])
    {
        if (deep[top[x]]<deep[top[y]])
            swap(x,y);
        change(dfn[top[x]],dfn[x],k,1,n,1);
        x=fa[top[x]];//向上跳 
    }
    if (deep[x]>deep[y])//x和y分别都在重链头上 
        swap(x,y);
    change(dfn[x],dfn[y],k,1,n,1);
}

int tree_ques(int x,int y)
{
    int ans=0;
    while (top[x]!=top[y])
    {
        if (deep[top[x]]<deep[top[y]])
            swap(x,y);
        ans=(ans+ques(dfn[top[x]],dfn[x],1,n,1))%mod;
        x=fa[top[x]];//这个地方写fa[x]会超时 
    }
    if (deep[x]>deep[y]) swap(x,y);
    ans=(ans+ques(dfn[x],dfn[y],1,n,1))%mod;
    return ans;
}

完整代码

luogu3384

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=200020;
int n,m,root,mod,add[maxn<<2],sum[maxn<<2],a[maxn];
int fa[maxn],deep[maxn],son[maxn],tot[maxn],top[maxn],dfn[maxn],id[maxn];
//son重儿子; tot子树的大小; top该点所在重链头; dfn遍历到的顺序(新的编号);  id：dfs序中原来的点对应的位置; 

struct Edge{
    int to,next;
}edge[maxn<<1];
int head[maxn],num_edge;

void add_edge(int from,int to)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].to=to;
    head[from]=num_edge;
}

//简单的dfs更新deep son fa 
void dfs1(int x,int f,int depth)
{
    fa[x]=f;
    deep[x]=depth;
    tot[x]=1;//错0 
    int maxnow=-1;
    for (int i=head[x]; i!=0; i=edge[i].next)
    {
        int to=edge[i].to;
        if (to!=f)
        {
            dfs1(to,x,depth+1);
            tot[x]+=tot[to];//回溯的时候更新tot和son 
            if (tot[to]>maxnow)
            {
                maxnow=tot[to];
                son[x]=to;
            }
        }
    }
}

//此处的dfs用来更新dfs序和top 
int cnt=0;//遍历时间计数器 
void dfs2(int x,int tp)
{//因为对于轻儿子来说,top[u]=u，对于重儿子来说，如果son[v]!=-1,那么top[v]=top[son[v]]  
    dfn[x]=++cnt;
    id[cnt]=x;//和dfn互为反数组 
    top[x]=tp;
    if (!son[x]) return;//先访问重孩子，再访问轻孩子 
    dfs2(son[x],tp);

    for (int i=head[x]; i!=0; i=edge[i].next)
    {
        int to=edge[i].to;
        if (to!=fa[x] && to!=son[x])//
            dfs2(to,to);
    }
}

//以下为线段树操作
void pushup(int rt)
{
    sum[rt]=(sum[rt<<1]+sum[rt<<1|1])%mod;
}

void pushdown(int rt,int ln,int rn)
{
    if (add[rt])
    {
        add[rt<<1]=(add[rt<<1]+add[rt])%mod;
        add[rt<<1|1]=(add[rt<<1|1]+add[rt])%mod;
        sum[rt<<1]=(sum[rt<<1]+add[rt]*ln)%mod;
        sum[rt<<1|1]=(sum[rt<<1|1]+add[rt]*rn)%mod;
        add[rt]=0;
    }
}

void build_tree(int rt,int l,int r)
{
    if (l==r)
    {
        sum[rt]=a[id[l]];//id里面保存dfs对应的本来的数字 
        return;//dfs序把路径转化成区间 
    }
    int mid=(l+r)>>1;
    build_tree(rt<<1,l,mid);
    build_tree(rt<<1|1,mid+1,r);
    pushup(rt);
}

void change(int L,int R,int C,int l,int r,int rt)
{
    if (L<=l && r<=R)
    {
        add[rt]=(add[rt]+C)%mod;
        sum[rt]=(sum[rt]+C*(r-l+1))%mod;
        return;
    }
    int mid=(l+r)>>1;
    pushdown(rt,mid-l+1,r-mid);
    if (L<=mid) change(L,R,C,l,mid,rt<<1);
    if (R>mid) change(L,R,C,mid+1,r,rt<<1|1);
    pushup(rt);
}

int ques(int L,int R,int l,int r,int rt)
{
    if (L<=l && r<=R) return sum[rt]%mod;
    int mid=(l+r)>>1;
    int ans=0;
    pushdown(rt,mid-l+1,r-mid);
    if (L<=mid) ans=(ans+ques(L,R,l,mid,rt<<1))%mod;
    if (R>mid) ans=(ans+ques(L,R,mid+1,r,rt<<1|1))%mod;
    return ans;
    pushup(rt);
}

void tree_add(int x,int y,int k)
{
    k%=mod;
    while (top[x]!=top[y])//x和y到重链头的路径加k 
    {
        if (deep[top[x]]<deep[top[y]])
            swap(x,y);
        change(dfn[top[x]],dfn[x],k,1,n,1);
        x=fa[top[x]];//向上跳 
    }
    if (deep[x]>deep[y])//x和y分别都在重链头上 
        swap(x,y);
    change(dfn[x],dfn[y],k,1,n,1);
}

int tree_ques(int x,int y)
{
    int ans=0;
    while (top[x]!=top[y])
    {
        if (deep[top[x]]<deep[top[y]])
            swap(x,y);
        ans=(ans+ques(dfn[top[x]],dfn[x],1,n,1))%mod;
        x=fa[top[x]];//这个地方写fa[x]会超时 
    }
    if (deep[x]>deep[y]) swap(x,y);
    ans=(ans+ques(dfn[x],dfn[y],1,n,1))%mod;
    return ans;
}

int main()
{
    int x,y,opt,k;
    scanf("%d%d%d%d",&n,&m,&root,&mod);
    for (int i=1; i<=n; i++) scanf("%d",&a[i]);
    for (int i=1; i<=n-1; i++)
    {
        scanf("%d%d",&x,&y);
        add_edge(x,y);
        add_edge(y,x);//要建双向变 
    }
    dfs1(root,root,1);
    dfs2(root,root);

    build_tree(1,1,n);
    for (int i=1; i<=m; i++)
    {
        scanf("%d",&opt);
        if (opt==1)
        {
            scanf("%d%d%d",&x,&y,&k);
            tree_add(x,y,k);
        }
        if (opt==2)
        {
            scanf("%d%d",&x,&y);
            printf("%d\n",tree_ques(x,y));
        }
        if (opt==3)
        {
            scanf("%d%d",&x,&k);
            change(dfn[x],dfn[x]+tot[x]-1,k,1,n,1);
        }
        if (opt==4)
        {
            scanf("%d",&x);
            printf("%d\n",ques(dfn[x],dfn[x]+tot[x]-1,1,n,1));
        }
    }
    return 0;
}

总结

说一下容易错的地方：
在倍增的时候 x = fa [ top[x] ]；因为这是每次都找一条重链上；
dfs2的时候要让cnt等于0