本文详细介绍了树链剖分的概念及其在解决树上数据结构问题中的应用，特别是针对洛谷P3384题目的解题思路。通过两遍深度优先搜索（DFS）对树进行剖分，并利用线段树进行区间维护和操作，实现四种操作：路径节点值的修改和求和、子树节点值的修改和求和。文章提供了完整的C++代码实现，并解释了线段树中懒惰标记的使用来优化时间复杂度。
题目描述
如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作：
操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z
操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和
操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z
操作4： 格式： 4 x 表示求以x为根节点的子树内所有节点值之和
输入格式
第一行包含4个正整数N、M、R、P，分别表示树的结点个数、操作个数、根节点序号和取模数（即所有的输出结果均对此取模）。
接下来一行包含N个非负整数，分别依次表示各个节点上初始的数值。
接下来N-1行每行包含两个整数x、y，表示点x和点y之间连有一条边（保证无环且连通）
接下来M行每行包含若干个正整数，每行表示一个操作，格式如下：
操作1： 1 x y z
操作2： 2 x y
操作3： 3 x z
操作4： 4 x
输出格式
输出包含若干行，分别依次表示每个操作2或操作4所得的结果（对P取模）
输入输出样例
输入 #1复制
5 5 2 24 7 3 7 8 0 1 2 1 5 3 1 4 1 3 4 2 3 2 2 4 5 1 5 1 3 2 1 3
输出 #1复制
2 21
说明/提示
时空限制：1s，128M
数据规模：
对于30%的数据： N \leq 10, M \leq 10N≤10,M≤10
对于70%的数据： N \leq {10}^3, M \leq {10}^3N≤103,M≤103
对于100%的数据： N \leq {10}^5, M \leq {10}^5N≤105,M≤105
（ 其实，纯随机生成的树LCA+暴力是能过的，可是，你觉得可能是纯随机的么233 ）
样例说明：
树的结构如下：
各个操作如下：
故输出应依次为2、21(重要的事情说三遍：记得取模)
这是一道树链剖分的模板题，这里主要是重链剖分，就是对于一棵树，我们用树链剖分大法将其剖分成一条一条的线性的链（主要是找重链）后，就可以用数据结构（如线段树）进行相应的多种操作了（如本题所提到的四种操作）。
具体做法是：我们先用dfs对这棵完整的树进行剖分，第一遍dfs：标记每个结点的父结点，重儿子，深度以及大小（这里的大小指的是以该结点为根的所有子树结点（包括该结点本身）的个数）。第二遍dfs：用一个时间戳标记每个结点在dfs序下的编号，标记每个结点的top结点（就是该结点所处的那条链的顶端结点），记录在dfs序的编号下每个结点的权值（也就是代码中我们建的w[]数组的作用），注意这里在跑dfs时我们优先遍历重链（也就是先遍历重儿子），因为每个结点就一个重儿子（也就是儿子结点中大小最大的那一个），这样操作后，对于每一条重链，从链的顶端到末尾这些结点在dfs序下的编号是连续的，根据这个特点，我们就可以用线段树对一条链进行维护和相关的修改和查询操作了，把每个结点在dfs序下的编号作为树中相应的每个节点的编号，在dfs序的编号下每个结点的权值作为该结点的值，（其实线段树就是用来维护w[]数组的），每个结点维护该区间所有编号所示结点的权值之和，这样就可以建立线段树完成相关操作了！
下面说一下对应的四种操作：
一、对于1、2两种操作，我们只需要用两个指针变量下x、y（也就是最短路径的起点和终点），在两个指针不在一条链时，让x指针永远指向所在链的顶端结点的深度大的结点（也就是所处链的靠下的那个结点），让其不断地向上跳，每次对x所处的链的顶端结点到x这个连续区间用线段树进行相应操作后让其跳到其链的顶端结点的上一个，直到跳到和y在同一条链上，在让x再指向x和y深度小的那个，对x到y这个连续区间用线段树进行相应操作，这样就实现了对最短路径完整的操作了！
二、对于3、4两种操作只需要对指定的根结点在dfs序下的编号到此编号加上根结点大小减一这个连续区间（即包含要修改的所有子树结点的区间）进行相应操作就行了！
但是在第一次提交时发现超时了，然后对线段树，又加了个懒惰标记（也可以说是下传标记或延时标记，也就是树的结构体中定义的add），其实很简单，因为在修改时相应区间的每个数都加上一个值，该区间的子区间的每个数也要加上这个值，所以在修改一个区间时，我们可以修改完这个区间后用懒惰标记先记录一下这个区间的每个数要加的值（记录在add里），这时就不用再继续修改它的子区间了，只需要在查询其子区间时再把它的懒惰标记下传给其子区间就行了（也就是把其子区间之前早就要加的值加上），这样本来在修改区间时要对所有涉及到的子区间都修改一遍，一直改到底，但这里记录完就不用往下遍历了，因此节省了很大的时间，这样超时问题就解决了！
完整代码：
#include <bits/stdc++.h>
#define int long long
const int maxn=1e5+5;
using namespace std;
typedef struct tree
{
int l,r,sum,add,len;
} tr;
tr tree[maxn<<2];
typedef struct Edge
{
int next,to;
} edg;
edg e[maxn<<2];
int n,m,r,mod,a[maxn],head[maxn<<2],cnt;
void AddEdge(int u,int v)
{
e[cnt].to=v;
e[cnt].next=head[u];
head[u]=cnt++;
}
int fa[maxn],son[maxn],depth[maxn],siz[maxn];
void dfs1(int u,int f)
{
fa[u]=f;
depth[u]=depth[f]+1;
siz[u]=1;
int maxsize=-1;
for(int i=head[u]; ~i; i=e[i].next)
{
int v=e[i].to;
if(v==f)
continue;
dfs1(v,u);
siz[u]+=siz[v];
if(siz[v]>maxsize)
{
maxsize=siz[v];
son[u]=v;
}
}
}
int tim,dfn[maxn],w[maxn],top[maxn];
void dfs2(int u,int t)
{
dfn[u]=++tim;
top[u]=t;
w[tim]=a[u];
if(!son[u])
return;
dfs2(son[u],t);
for(int i=head[u]; ~i; i=e[i].next)
{
int v=e[i].to;
if(v==fa[u]||v==son[u])
continue;
dfs2(v,v);
}
}
void pushup(int p)
{
tree[p].sum=(tree[p<<1].sum+tree[p<<1|1].sum)%mod;
}
void pushdown(int p)
{
if(!tree[p].add)
return;
tree[p<<1].sum=(tree[p<<1].sum+tree[p<<1].len*tree[p].add)%mod;
tree[p<<1].add=(tree[p<<1].add+tree[p].add)%mod;
tree[p<<1|1].sum=(tree[p<<1|1].sum+tree[p<<1|1].len*tree[p].add)%mod;
tree[p<<1|1].add=(tree[p<<1|1].add+tree[p].add)%mod;
tree[p].add=0;
}
void build(int p,int l,int r)
{
tree[p].l=l;
tree[p].r=r;
tree[p].len=tree[p].r-tree[p].l+1;
if(l==r)
{
tree[p].sum=w[l]%mod;
return;
}
int mid=(l+r)>>1;
build(p<<1,l,mid);
build(p<<1|1,mid+1,r);
pushup(p);
}
void modify(int p,int l,int r,int x)
{
if(tree[p].l>=l&&tree[p].r<=r)
{
tree[p].sum+=tree[p].len*x;
tree[p].sum%=mod;
tree[p].add+=x;
tree[p].add%=mod;
return;
}
pushdown(p);
int mid=(tree[p].l+tree[p].r)>>1;
if(l<=mid)
modify(p<<1,l,r,x);
if(r>mid)
modify(p<<1|1,l,r,x);
pushup(p);
}
int query(int p,int l,int r)
{
if(tree[p].l>=l&&tree[p].r<=r)
{
return tree[p].sum%mod;
}
pushdown(p);
int mid=(tree[p].l+tree[p].r)>>1;
int ans=0;
if(l<=mid)
ans+=query(p<<1,l,r)%mod;
if(r>mid)
ans+=query(p<<1|1,l,r)%mod;
return ans%mod;
}
void modify_chain(int x,int y,int z)
{
z%=mod;
while(top[x]!=top[y])
{
if(depth[top[x]]<depth[top[y]])
swap(x,y);
modify(1,dfn[top[x]],dfn[x],z);
x=fa[top[x]];
}
if(depth[x]>depth[y])
swap(x,y);
modify(1,dfn[x],dfn[y],z);
}
int query_chain(int x,int y)
{
int tot=0;
while(top[x]!=top[y])
{
if(depth[top[x]]<depth[top[y]])
swap(x,y);
tot+=query(1,dfn[top[x]],dfn[x]);
tot%=mod;
x=fa[top[x]];
}
if(depth[x]>depth[y])
swap(x,y);
tot+=query(1,dfn[x],dfn[y]);
return tot%mod;
}
void modify_son(int x,int z)
{
modify(1,dfn[x],dfn[x]+siz[x]-1,z);
}
int query_son(int x)
{
return query(1,dfn[x],dfn[x]+siz[x]-1)%mod;
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
memset(head,-1,sizeof(head));
cin>>n>>m>>r>>mod;
for(int i=1; i<=n; i++)
{
cin>>a[i];
}
int N=n-1;
while(N--)
{
int u,v;
cin>>u>>v;
AddEdge(u,v);
AddEdge(v,u);
}
dfs1(r,r);
dfs2(r,r);
build(1,1,n);
while(m--)
{
int q,x,y,z;
cin>>q;
if(q==1)
{
cin>>x>>y>>z;
modify_chain(x,y,z);
}
else if(q==2)
{
cin>>x>>y;
int ans=query_chain(x,y);
cout<<ans<<endl;
}
else if(q==3)
{
cin>>x>>z;
modify_son(x,z);
}
else
{
cin>>x;
int ans=query_son(x);
cout<<ans<<endl;
}
}
}
下面对该模板代码进行一下说明：
#include <bits/stdc++.h>
#define int long long
const int maxn=1e5+5;
using namespace std;
typedef struct tree
{
int l,r,sum,add,len;//l，r区间左右界，sum是维护的区间和，add是懒惰标记，len是区间长度
} tr;
tr tree[maxn<<2];//tree[]表示线段树中的每个结点
typedef struct Edge//为了方便，用链式前向星建图表示初始的树
{
int next,to;//next表示与当前边同起点的上一条边的编号，to是当前边的终点编号
} edg;
edg e[maxn<<2];
int n,m,r,mod,a[maxn],head[maxn<<2],cnt;
void AddEdge(int u,int v)//链式前向星的加边建图函数
{
e[cnt].to=v;
e[cnt].next=head[u];
head[u]=cnt++;
}
//！注意：下面两个dfs用到的数组中只有w[]数组的下标为结点在dfs序下的编号，其他数组的下标均为结点的初始编号！
int fa[maxn],son[maxn],depth[maxn],siz[maxn];
//fa[i]表示初始编号为i的结点对应的父结点的初始编号，son[i]表示初始编号为i的结点对应的儿子结点的初始编号
//depth[i]表示初始编号为i的结点的深度,siz[i]表示初始编号为i的结点的大小
void dfs1(int u,int f)//u表示当前结点的初始编号，f为当前结点的父结点的初始编号
{
fa[u]=f;//u的父结点记为f
depth[u]=depth[f]+1;//每个结点的深度都等于其父结点深度+1
siz[u]=1;//每个结点都先算上其本身的大小：1（后面再加）
int maxsize=-1;
for(int i=head[u]; ~i; i=e[i].next)//从以u为起点的最后一条边开始链式前向星的倒序遍历
{
int v=e[i].to;
if(v==f)//当上一条边的终点遍历到u时（也就是这条链的顶端）
continue;//继续下一个
dfs1(v,u);//每次遍历到新的以u为起点的儿子结点时递归更新其儿子结点的信息
siz[u]+=siz[v];//每次递归更新完一个儿子结点，当前父结点的大小要加上此儿子的大小
if(siz[v]>maxsize)
{
maxsize=siz[v];//不断更新最大的儿子结点的大小
son[u]=v;//不断更新u的重儿子为当前结点大小最大的儿子，最后就能找到其重儿子了
}
}
}
int tim,dfn[maxn],w[maxn],top[maxn];
//tim是用来给每个结点在dfs序下编号的时间戳，dfs[i]表示初始编号为i的结点在dfs序下的编号，w[i]表示dfs序的编号为i的结点的权值，top[i]表示初始编号为i的结点所处链的顶端结点的编号
void dfs2(int u,int t)
{
dfn[u]=++tim;//用tim给当前结点u在dfs下编号
top[u]=t;//当前结点所处链的顶端结点的编号为t
w[tim]=a[u];//用w[]数组记录dfs序的编号为tim的结点的值为对应原初始编号为u的结点的权值
if(!son[u])
return;//没有重儿子时，说明遍历到了该重链的尾结点，退出当前dfs即可
dfs2(son[u],t);//有重儿子就继续递归更新其重儿子的信息
for(int i=head[u]; ~i; i=e[i].next)//从以u为起点的最后一条边开始链式前向星的倒序遍历
{
int v=e[i].to;
if(v==fa[u]||v==son[u])
continue;
dfs2(v,v);//对新的以u为顶端结点的链进行操作
}
}
//----------------以下为线段树的相关操作---------------------------------
void pushup(int p)//上传更新维护根结点的值
{
tree[p].sum=(tree[p<<1].sum+tree[p<<1|1].sum)%mod;
}
void pushdown(int p)//下传懒惰标记更新子区间的值
{
if(!tree[p].add)
return;//如果没有懒惰标记就不用下传了
//子树的sum值=原来的sum值+其根结点的懒惰标记记录的每个数要加的值*该子树所示区间的长度
//（懒惰标记记录的每个数要加的值*该子树所示区间的长度）即该区间要加的总的值
tree[p<<1].sum=(tree[p<<1].sum+tree[p<<1].len*tree[p].add)%mod;
//子树的标记值=原来的标记值+其根结点下传的标记值
tree[p<<1].add=(tree[p<<1].add+tree[p].add)%mod;
tree[p<<1|1].sum=(tree[p<<1|1].sum+tree[p<<1|1].len*tree[p].add)%mod;
tree[p<<1|1].add=(tree[p<<1|1].add+tree[p].add)%mod;
tree[p].add=0;//懒惰标记下传给子树后要清除（防止下次询问时再加上此标记的值，因为下传完之后该加的都加了）
}
void build(int p,int l,int r)
{
tree[p].l=l;
tree[p].r=r;
tree[p].len=tree[p].r-tree[p].l+1;
if(l==r)
{
tree[p].sum=w[l]%mod;
return;
}
int mid=(l+r)>>1;
build(p<<1,l,mid);
build(p<<1|1,mid+1,r);
pushup(p);
}
void modify(int p,int l,int r,int x)
{
if(tree[p].l>=l&&tree[p].r<=r)//这里因为要用懒惰标记所以找涉及的区间修改就行了
{
tree[p].sum+=tree[p].len*x;//该结点sum值=原来的sum值+其区间长度*该区间每个数要加的值
tree[p].sum%=mod;
tree[p].add+=x;
tree[p].add%=mod;
return;
}
pushdown(p);//当前区间不在所找范围要遍历其子区间时要先把懒惰标记下传给其子区间
int mid=(tree[p].l+tree[p].r)>>1;
if(l<=mid)
modify(p<<1,l,r,x);
if(r>mid)
modify(p<<1|1,l,r,x);
pushup(p);
}
int query(int p,int l,int r)
{
if(tree[p].l>=l&&tree[p].r<=r)
{
return tree[p].sum%mod;
}
pushdown(p);//同上，当前区间不在所找范围要遍历其子区间时要先把懒惰标记下传给其子区间
int mid=(tree[p].l+tree[p].r)>>1;
int ans=0;
if(l<=mid)
ans+=query(p<<1,l,r)%mod;
if(r>mid)
ans+=query(p<<1|1,l,r)%mod;
return ans%mod;
}
//-----------------以上为线段树的相关操作-------------------------
//修改链
void modify_chain(int x,int y,int z)//x，y为路径的起点和终点对应结点的初始编号，z为路径上每个点要加的值
{
z%=mod;
while(top[x]!=top[y])//只要x和y所示结点所处链的顶端结点不同，即不在一条链
{
if(depth[top[x]]<depth[top[y]])
swap(x,y);//该交换让x指针永远指向所在链的顶端结点的深度大的结点（也就是所处链的靠下的那个结点）
modify(1,dfn[top[x]],dfn[x],z);//每次对dfs序下x所处的链的顶端结点编号到x编号这个连续区间用线段树进行修改操作
x=fa[top[x]];//让x跳到其链的顶端结点的上一个
}
if(depth[x]>depth[y])
swap(x,y);//这时，已经退出了while循环，所以x跳到和y在同一条链上，让x再指向x和y深度小的那个
modify(1,dfn[x],dfn[y],z);//对dfs序下x到y编号这个连续区间用线段树进行修改操作
}
//查询链
int query_chain(int x,int y)//同上，换成套线段树的查询函数即可
{
int tot=0;
while(top[x]!=top[y])
{
if(depth[top[x]]<depth[top[y]])
swap(x,y);
tot+=query(1,dfn[top[x]],dfn[x]);
tot%=mod;
x=fa[top[x]];
}
if(depth[x]>depth[y])
swap(x,y);
tot+=query(1,dfn[x],dfn[y]);
return tot%mod;
}
//修改子结点
void modify_son(int x,int z)
{
modify(1,dfn[x],dfn[x]+siz[x]-1,z);//对指定的始编号为x的根结点初在dfs序下的编号到此编号加上根结点大小减一这个连续区间（即包含要修改的所有子树结点的区间）进行修改操作
}
//查询子结点
int query_son(int x)
{
return query(1,dfn[x],dfn[x]+siz[x]-1)%mod;//同上，这里进行查询操作
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
memset(head,-1,sizeof(head));
cin>>n>>m>>r>>mod;
for(int i=1; i<=n; i++)
{
cin>>a[i];
}
int N=n-1;
while(N--)
{
int u,v;
cin>>u>>v;
AddEdge(u,v);
AddEdge(v,u);
}
dfs1(r,r);
dfs2(r,r);
build(1,1,n);
while(m--)
{
int q,x,y,z;
cin>>q;
if(q==1)
{
cin>>x>>y>>z;
modify_chain(x,y,z);
}
else if(q==2)
{
cin>>x>>y;
int ans=query_chain(x,y);
cout<<ans<<endl;
}
else if(q==3)
{
cin>>x>>z;
modify_son(x,z);
}
else
{
cin>>x;
int ans=query_son(x);
cout<<ans<<endl;
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
