[模板]树链剖分讲解与模板
树链剖分的思想比较神奇
它的思想是：把一棵树拆成若干个不相交的链，然后用一些数据结构去维护这些链
重儿子：该节点的子树中,节点个数最多的子树的根节点(也就是和该节点相连的点)，即为该节点的重儿子
重边：连接该节点与它的重儿子的边
重链：由一系列重边相连得到的链
轻链：由一系列非重边相连得到的链
变量声明：
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]]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]]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
#include1,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]]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