目录
一、关于树链剖分
你的好盆友最近抛给你这样一个难题(无中生友)：
" 一棵树由n个节点，每个节点都有一个权值w，现在想让你对这棵树完成下列操作：
1.把节点u的权值改为t
2.询问节点u到节点v的权值和
3.节点u到v的最大值 "
你看了看题目，发现这就是树链剖分的板子题...
好吧，那如果你不会树链剖分呢？
...
于是你的朋友告诉你这是树链剖分，并因为你不会树链剖分把你嘲讽了(开玩笑而已啦)...
只观察这个问题的三个操作，你惊讶的发现这是线段树所擅长的事情，即单点修改，区间查询。
实际上，如果这棵树退化成一条链，那么你完全可以用线段树来解决这个问题。
你思考了一下，得出了树链剖分是什么东西：
树链剖分(Query on a Tree)是用来解决维护静态树上路径信息问题的一种数据结构。
现在，机智的你开始考虑如何解决一般形态的树，你发现不论如何修改树的点权，这棵树的形态都不会发生改变。因此只要将一些点链接起来，也就是说把一棵树剖分成若干条链。这样，你维护的路径就变成了几条链，且每一条链都可以作为一个区间，这时你就可以快乐地使用线段树维护了。
树链剖分的难点以及核心也就在这里，如何恰当地将一棵树剖分成若干条“链”。这之后只要将这些作为序列进行维护就可以了。
二、树链剖分实现流程
这里使用的树链剖分方法为轻，重边剖分；
- 轻，重边剖分将树的边分为轻边，重边两种，我们记
size[u]为以u节点为根的子树节点个数，对于任意点u，我们把u的子节点的size值最大的一个节点v叫做“v是u的重儿子”，其中边<u,v>为重边，其余边为轻边。
一棵树的轻边与重边：
- 当我们发现节点
u的子节点的size[v]大于此时我们已知的重儿子的子树节点数量size[son[u]]时，说明此时son[u]不是最优，那么更改v为重儿子就好了，即if(size[v]>size[son[u]]) son[u]=v;。
特殊地，若节点u的子节点的子树节点个数相等，那么我们把第一个遍历到的子节点作为节点u的重儿子。
轻重边的性质：
1. 若边(u,v)为轻边，那么\(size[v]\leq size[u]/2\)
由于节点u一定有一个重儿子v，节点v的子树大小至少要大于size[u]/2，否则v就不能作为u的重儿子。
2. 从根节点到某一点u的路径中的轻边个数\(\leq O(logn)\)
根据贪心思想，当节点u在叶子节点的时候保证轻边的数量尽量多。由于每经过一条轻边，都会至少减少一半，所以该路径至多有\(O(logn)\)条轻边。
3. 重路径：当一条路径全部由重边组成，那么这个路径为重路径(特殊地，一个点也作为一条重路径)。 有性质：根结点到节点u的路径中，有不超过\(O(logn)\)条轻边和\(O(logn)\)条重路径。
根结点到节点u的轻边个数为\(O(logn)\)条，因此重路径的数量为\(O(logn)\)。
- 当我们对树进行深度优先遍历时，我们优先遍历重儿子，对于重链中的每一个节点
u，始终记录这条重链中深度最小的节点存入top[u]中，其中top数组表示为一条重链中该点能向上跳到的最远节点。
当遍历到递归边界时(!son[u]没有重儿子)，我们回溯并开始遍历轻边。遍历到轻边的节点v时，记录top[v]=v。
下图表现了遍历的顺序(包含回溯)：
遍历时我们还可以得出每个节点遍历的顺序(DFS序/时间戳)，我们把这个顺序记录到seg[ ]数组中，这样就把树上的节点一一映射到序列上了。同时为了我们知道序列上的节点对应树上是哪个节点，我们建立数组rev[ ]记录，即rev[cnt]=u，其中cnt为遍历的顺序。
下图为top,seg数组存储的模拟：
由于我们优先遍历重链，所以我们能保证重链中的节点的DFS序是连续的，这样我们在查询的时候只要线段树查询seg[top[u]]~seg[u]这个区间就可以了。
我们对树进行剖分后，此时维护
<u,v>的路径，我们处理出u，v的最近公共祖先，如果top[x]，top[y]不同，那么显然他们的LCA不可能在top深度较大的那条重路径上。
我们优先处理深度较大的一条路径，重边只需要线段树维护，轻边则直接跳过，访问下一个重边。由于拆分重路径的过程就是在求LCA的过程中，我们会选择u，v中深度较深的一点来走，直到u==v，这实际上是暴力思想。
由于我们已经处理出top[ ]数组，我们不需要一步一步向上跳，直接由x跳到fa[top[x]]处。此时由于重链是一个连续的区间，我们可以用线段树进行维护。
当x,y的top相同的时候，说明他们在同一条重路径上，此时的路径也是序列上的区间，且x,y中深度较小的那个点为x,y的最近公共祖先。这样我们就能把任意路径拆分成若干条重路径，转化为区间后就可以用线段树进行处理。
二、树链剖分具体实现
下面结合代码具体分析，以单点修改，区间查询为例
1.需要表示的变量
fa[u]; //节点u的父亲节点，在求LCA时涉及
dep[u]; //节点u的深度，在求LCA时涉及
size[u]; //节点u的子树节点大小，在求重儿子时涉及
son[u]; //节点u的重儿子，在遍历重链以及求dfs序时涉及。
.................
top[u]; //重路径节点u的顶部节点，在求LCA时涉及
seg[u]; //树上节点对应的dfs序，也可以理解为转化到序列上的节点编号，在修改/查询重链时涉及
rev[u]; //dfs序中的编号对应树上的节点编号，或对应的权值，在初始化线段树时涉及2.储存一棵树
采用树图的方式存储，使用链式前向星。
个人比较喜欢使用数组的方式，当然也可以用向量来存。
CodeA：
int first[5000],next[5000],go[5000],tot=0;
inline void add_edge(int u,int v){
next[++tot]=first[u];
first[u]=tot;
go[tot]=v;
}
add_edge(u,v);//主函数内
add_edge(v,u);CodeB：
vector<int> g[5000];
g[u].push_back(v);//主函数内
g[v].push_back(u);3.第一次遍历，处理fa，dep，size，son数组
Code：
比较简洁的写法。
inline void dfs1(int u){
size[u]=1;//子树中只有节点u，因此大小为1
for(int e=frist[u];e;e=next[e]){
int v=go[e];
if(fa[u]==v) continue;//不加会成环
fa[v]=u;//标记v的父亲
dep[v]=dep[u]+1;//计算深度
dfs1(v);
size[u]+=size[v];//回溯的时候累计子树节点大小
if(size[v]>size[son[u]]) son[u]=v; //更新重儿子
}
}
dfs1(1);//主函数内4.第二次遍历，处理top，seg，rev数组
Code：
inline void dfs2(int u,int fath){//这里fath为u的父亲节点
seg[u]=++seg[0];//如果节点序号不涉及0，那么利用一下数组就不用再建变量了
rev[seg[0]]=b[u];//存储dfs序的节点对应树上节点的权值
top[u]=fath;//重儿子所在重链的顶部节点
if(!son[u]) return;//到头了，回溯
dfs2(son[u],fath);//不断遍历重儿子
for(int e=frist[u];e;e=next[e]){//此时遍历轻儿子
int v=go[e];
if(fa[u]==v||v==son[u]) continue;//保证不产生环且不再遍历重儿子
dfs2(v,v);//自己的top是自己
}
}
dfs1(1);//主函数内5.初始化线段树
和一般线段树是一样的。
Code：
inline void push_up(int k){
sumv[k]=sumv[k<<1]+sumv[k<<1|1];
}
inline void build(int k,int l,int r){
if(l==r){
sumv[k]+=rev[l];//sumv记录了线段树的区间和
return;
}
int mid=(l+r)>>1;
build(k<<1,l,mid);
build(k<<1|1,mid+1,r);
push_up(k);//更新，在之后的代码中同理
}
build(1,1,n);//主函数内6.单点修改
和一般线段树也是一样的...
inline void modify_single_point(int k,int l,int r,int pos,int val){
if(l==r){
sumv[k]+=val;
return;
}
mid=(l+r)>>1;
if(pos<=mid) modify_single_point(k<<1,l,mid,pos,val);
else modify_single_point(k<<1|1,mid+1,r,pos,val);
push_up(k);
}
modify_single_point(1,1,n,seg[x],val);//主函数内7.区间修改---以x为根结点的子树内节点的值都加val
seg[ ]数组内保证了dfs序(不懂的话可以对照上面的图模拟一下)，因此seg[x]~seg[x]+size[x]-1这一闭区间都是x子树中的节点，接下来就是线段树负责的事了。
Code：
inline void push_down(int k,int l,int r,int mid){
if(lazy[k]==0) reutrn;
lazy[k<<1]+=lazy[k];
lazy[k<<1|1]+=lazy[k];
sumv[k<<1]+=lazy[k]*(mid-l+1);
sumv[k<<1|1]+=lazy[k]*(r-mid);
lazy[k]=0;
}
inline void modify_range(int k,int l,int r,int L,int R,int val){
if(l>=L&&r<=R){
lazy[k]+=val;//延迟标记
sumv[k]+=val*(r-l+1);
return;
}
push_down(k,l,r,mid);//若下文出现push_down,那么同本段代码
int mid=(l+r)>>1;
if(mid>=L) modify_range(k<<1,l,mid,L,R,val);
if(mid<R) modify_range(k<<1|1,mid+1,r,L,R,val);
push_up(k);
}
modify_range(1,1,n,seg[x],seg[x]+size[x]-1,val);//主函数中8.区间修改---节点x到节点y的最短路径中同时加val
求LCA，并更新区间的值。
Code：
inline void solve_as_lca(int x,int y,int val){
while(top[x]!=top[y]){//不相同就一直跳
if(dep[top[x]]<dep[top[y]]) swap(x,y);//先跳top深的
modify_range(1,1,n,seg[top[x]],seg[x],val);//与上一个函数一样
x=fa[top[x]];//更新，跳到重链顶点的父节点上
}
if(dep[x]>dep[y]) swap(x,y);//此时x,y已经在一条重链上，那么区间更新是由深度浅的点到深度深的点
modify_range(1,1,n,seg[x],seg[y],val);
}
solve_as_lca(x,y,val);//主函数内9.区间查询---以x为根结点的子树内节点的值的和
与操作7是一样的，注意要写push_down()。
Code：
inline int query_range(int k,int l,int r,int L,int R){
if(l>=L&&r<=R) return sumv[k];
push_down(k,l,r,mid);
int mid=(l+r)/2,res=0;
if(mid>=L) res+=query_range(k<<1,l,mid,L,R);
if(mid<R) res+=query_range(k<<1|1,mid+1,r,L,R);
return res;
}
query(1,1,n,seg[x],seg[x]+size[x]-1);//主函数中10.区间查询---节点x到节点y的最短路径中节点的和
同样借助LCA的方式，同时累计答案。
Code：
inline int query_as_lca(int x,int y){
int res=0;
while(top[x]!=top[y]){
if(dep[top[x]]<dep[top[y]]) swap(x,y);
res+=query_range(1,1,n,seg[top[x]],seg[x]);//与操作9的函数是一样的
x=fa[top[x]];
}
if(dep[x]>dep[y]) swap(x,y);
res+=query_range(1,1,n,seg[x],seg[y]);
return res;
}
printf("%d",query_as_lca(x,y));//主函数内11.区间查询---节点x到节点y的最短路径中的最大值/最小值
给出最大值的求法，求最小值时将res赋成最大值，其余同最大值求法。
Code：
#define INF 0x3f3f3f3f
inline int query_range_max(int k,int l,int r,int L,int R){
if(l>=L&&r<=R) return maxv[k];
int mid=(l+r)/2,res=-INF;
if(mid>=L) res=max(res,query_range(k<<1,l,mid,L,R));
if(mid<R) res=max(res,query_range(k<<1|1,mid+1,r,L,R));
return res;
}
inline int query_for_max(int x,int y){
int res=-INF;
while(top[x]!=top[y]){
if(dep[top[x]]<dep[top[y]]) swap(x,y);
res=max(res,query_range_max(1,1,n,seg[top[x]],seg[x]));
x=fa[top[x]];
}
if(dep[x]>dep[y]) swap(x,y);
res=max(res,query_range_max(1,1,n,seg[x],seg[y]));
return res;
}
printf("%d",query_for_max(x,y));//主函数内以上就是树链剖分的具体实现以及一些基本操作，
现在你已经可以吊打你的好朋友了(〃'▽'〃)。
三、例题
例1：P3384 【模板】树链剖分
我们所学的操作已经涵盖了题目要求的操作，直接上代码啦（不要忘记取模运算）。
Code：
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e5+10;
int sumv[N<<2],lazy[N<<2];
int n,q,rt,mod,b[N];
int dep[N],fa[N],seg[N],rev[N],son[N],size[N],top[N];
int first[N<<2],next[N<<1],go[N<<1],tot;
inline void add_edge(int u,int v){
next[++tot]=first[u];
first[u]=tot;
go[tot]=v;
}
inline void dfs1(int u){
size[u]=1;
for(int e=first[u];e;e=next[e]){
int v=go[e];
if(fa[u]==v) continue;
fa[v]=u;dep[v]=dep[u]+1;
dfs1(v);
size[u]+=size[v];
if(size[v]>size[son[u]]) son[u]=v;
}
}
void dfs2(int u,int fath){
seg[u]=++seg[0];
rev[seg[0]]=b[u];
top[u]=fath;
if(!son[u]) return;
dfs2(son[u],fath);
for(int e=first[u];e;e=next[e]){
int v=go[e];
if(v==fa[u]||v==son[u])continue;
dfs2(v,v);
}
}
inline void push_up(int k){sumv[k]=(sumv[k<<1]+sumv[k<<1|1])%mod;}
inline void push_down(int k,int l,int r,int mid){
if(!lazy[k]) return;
lazy[k]%=mod;
lazy[k<<1]+=lazy[k];lazy[k<<1]%=mod;
lazy[k<<1|1]+=lazy[k];lazy[k<<1|1]%=mod;
sumv[k<<1]+=lazy[k]*(mid-l+1);sumv[k<<1]%=mod;
sumv[k<<1|1]+=lazy[k]*(r-mid);sumv[k<<1|1]%=mod;
lazy[k]=0;
}
inline void build(int k,int l,int r){
if(l==r){sumv[k]=rev[l]%mod;return;}
int mid=(l+r)>>1;
build(k<<1,l,mid);
build(k<<1|1,mid+1,r);
push_up(k);
}
inline int query_range(int k,int l,int r,int L,int R){
if(l>=L&&r<=R){return sumv[k]%mod;}
int mid=(l+r)>>1,res=0;//change position
push_down(k,l,r,mid);
if(mid>=L) res+=query_range(k<<1,l,mid,L,R)%mod;res%=mod;
if(mid<R) res+=query_range(k<<1|1,mid+1,r,L,R)%mod;res%=mod;
return res;
}
inline void modify_range(int k,int l,int r,int L,int R,int val){
if(l>=L&&r<=R){
val%=mod;lazy[k]+=val;lazy[k]%=mod;
sumv[k]+=val*(r-l+1);sumv[k]%=mod;
return;
}
int mid=(l+r)>>1;
push_down(k,l,r,mid);
if(mid>=L) modify_range(k<<1,l,mid,L,R,val);
if(mid<R) modify_range(k<<1|1,mid+1,r,L,R,val);
push_up(k);
}
inline int query_as_lca(int x,int y){
int res=0;
while(top[x]!=top[y]){
if(dep[top[x]]<dep[top[y]]) swap(x,y);
res+=query_range(1,1,n,seg[top[x]],seg[x]);res%=mod;
x=fa[top[x]];
}
if(dep[x]>dep[y]) swap(x,y);
res+=query_range(1,1,n,seg[x],seg[y])%mod;res%=mod;
return res;
}
inline void modify_as_lca(int x,int y,int val){
while(top[x]!=top[y]){
if(dep[top[x]]<dep[top[y]]) swap(x,y);
modify_range(1,1,n,seg[top[x]],seg[x],val);
x=fa[top[x]];
}
if(dep[x]>dep[y]) swap(x,y);
modify_range(1,1,n,seg[x],seg[y],val);
}
int main()
{
scanf("%d%d%d%d",&n,&q,&rt,&mod);
for(int i=1;i<=n;i++) scanf("%d",&b[i]),b[i]%=mod;
for(int i=1,u,v;i<n;i++){
scanf("%d%d",&u,&v);
add_edge(u,v);add_edge(v,u);
}
dfs1(rt);dfs2(rt,rt);
build(1,1,n);
for(int t=1,op,x,y,z;t<=q;t++){
scanf("%d",&op);
if(op==1){
scanf("%d%d%d",&x,&y,&z);
modify_as_lca(x,y,z);
}
else if(op==2){
scanf("%d%d",&x,&y);
printf("%d\n",query_as_lca(x,y));
}
else if(op==3){
scanf("%d%d",&x,&z);
modify_range(1,1,n,seg[x],seg[x]+size[x]-1,z);
}
else if(op==4){
scanf("%d",&x);
printf("%d\n",query_range(1,1,n,seg[x],seg[x]+size[x]-1)%mod);
}
}
return 0;
}其余一些例题：
例2：P2146 [NOI2015]软件包管理器
例3：P2590 [ZJOI2008]树的统计
例4：[JLOI2014]松鼠的新家