基础 DFS序、树链剖分

最新推荐文章于 2025-08-22 22:52:54 发布
原创 最新推荐文章于 2025-08-22 22:52:54 发布 · 280 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#树结构

DFS序和树链剖分都是在树的前提下才有效的。

DFS序

DFS，即对树进行DFS时遍历的顺序。记录每个点被遍历之前遍历过的点数 i n in in 和遍历完以该点为根的子树后遍历过的点数 o u t out out。若点 v v v 为 u u u 子树中的点，则一定满足 i n u ⩽ i n v ⩽ o u t u in_u \leqslant in_v \leqslant out_u inu​⩽inv​⩽outu​。因此任意一点 u u u 的子树可以用区间 [ i n u , o u t u ] [in_u,out_u] [inu​,outu​] 来表示。
求DFS序模板：

vector<int>G[100];
int ct,in[100],out[100];
void DFS(int x){
    ct++;
    in[x]=ct;
    for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
	    DFS(*T);
    }
    out[x]=ct;
}

点修改,子树查询
对于点 u u u 的修改，只需要在 i n u in_u inu​ 处单点修改。对于子树 u u u 的查询，即对区间 [ i n u , o u t u ] [in_u,out_u] [inu​,outu​] 内的点权求和。因此使用树状数组优化修改与查询。
时间复杂度 O ( n + q l o g 2 n ) O(n+qlog_2n) O(n+qlog2​n)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#define R register int
#define L long long
#define I inline
#define N 1000001
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    while(t<48||t>57){
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
}
int in[N],out[N],Last[N],End[N],Next[N],t[N],ct;
I void Link(int&x,int&y){
    ct++;
    End[ct]=y;
    Next[ct]=Last[x];
    Last[x]=ct;
}
I void DFS(int x){
    ct++;
    in[x]=ct;
    for(R i=Last[x];i!=0;i=Next[i]){
        DFS(End[i]);
    }
    out[x]=ct;
}
L c[N];
I void Add(int x,int d){
    for(R i=x;i<N;i+=i&-i){
        c[i]+=d;
    }
}
I L Get(int x){
    L s=0;
    for(R i=x;i!=0;i-=i&-i){
        s+=c[i];
    }
    return s;
}
int main(){
    int m,a,b,n;
    Read(n);
    Read(m);
    for(R i=1;i<=n;i++){
        Read(t[i]);
    }
    for(R i=2;i<=n;i++){
        Read(a);
        Link(a,i);
    }
    ct=0;
    DFS(1);
    for(R i=1;i<=n;i++){
        Add(in[i],t[i]);
    }
    for(R i=0;i!=m;i++){
        Read(b);
        Read(a);
        if(b==1){
   	        Read(b);
   	        Add(in[a],b-t[a]);
   	        t[a]=b;
  	    }else{
   	        printf("%lld\n",Get(out[a])-Get(in[a]-1));
  	    }
    }
    return 0;
}

子树修改,点查询
对 u u u 子树修改即对区间 [ i n u , o u t u ] [in_u,out_u] [inu​,outu​] 区间修改，改为差分，对点 i n u in_u inu​ 和 o u t u + 1 out_u+1 outu​+1 的单点修改。单点查询也就改为了前缀查询。同样使用树状数组。
时间复杂度 O ( n + q l o g 2 n ) O(n+qlog_2n) O(n+qlog2​n)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define N 1000001
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    bool tag=false;
    while(t<48||t>57){
    	if(t=='-'){
    	    tag=true;
	    }
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
    if(tag==true){
    	x=-x;
    }
}
int in[N],out[N],Last[N],Next[N],t[N],ct;
I void Link(int x,int y){
    Next[y]=Last[x];
    Last[x]=y;
}
I void DFS(int x){
    ct++;
    in[x]=ct;
    for(R i=Last[x];i!=0;i=Next[i]){
	    DFS(i);
    }
    out[x]=ct;
}
L c[N];
I void Modify(int x,const int d){
    for(R i=x;i<N;i+=i&-i){
	    c[i]+=d;
    }
}
I L GetSum(int x){
    L res=0;
    for(R i=x;i!=0;i&=i-1){
	    res+=c[i];
    }
    return res;
}
int main(){
    int n,q,opt,a,b;
    Read(n);
    Read(q);
    for(R i=1;i<=n;i++){
	    Read(t[i]);
    }
    for(int i=2;i<=n;i++){
	    Read(a);
	    Link(a,i);
    }
    DFS(1);
    for(R i=0;i!=q;i++){
	    Read(opt);
	    Read(a);
	    if(opt==1){
			Read(b);
	   		Modify(in[a],b);
	    	Modify(out[a]+1,-b);
		}else{
	    	printf("%lld\n",GetSum(in[a])+t[a]);
		}
    }
    return 0;
}

子树修改,子树查询
显然就是对区间修改，区间查询。用树状数组即可。
时间复杂度 O ( n + q l o g 2 n ) O(n+qlog_2n) O(n+qlog2​n)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define N 1000001
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    bool tag=false;
    while(t<48||t>57){
    	if(t=='-'){
    	    tag=true;
		}
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
    if(tag==true){
    	x=-x;
    }
}
int in[N],out[N],Last[N],Next[N],t[N],pos[N],ct;
I void Link(int x,int y){
    Next[y]=Last[x];
    Last[x]=y;
}
I void DFS(int x){
    ct++;
    in[x]=ct;
    pos[ct]=x;
    for(R i=Last[x];i!=0;i=Next[i]){
		DFS(i);
    }
    out[x]=ct;
}
L c[N][2],sum[N];
I void Modify(int x,const int d){
    for(R i=x;i<N;i+=i&-i){
        c[i][0]+=d;
		c[i][1]+=(L)d*x;
    }
}
I L GetSum(int x){
    L res1=0,res2=0;
    for(R i=x;i!=0;i&=i-1){
        res1+=c[i][0];
		res2+=c[i][1];
    }
    return res1*(1+x)-res2;
}
int main(){
    int n,q,opt,a,b;
    Read(n);
    Read(q);
    for(R i=1;i<=n;i++){
		Read(t[i]);
    }
    for(int i=2;i<=n;i++){
		Read(a);
		Link(a,i);
    }
    DFS(1);
    for(R i=1;i<=n;i++){
		sum[i]=sum[i-1]+t[pos[i]];
    }
    for(R i=0;i!=q;i++){
		Read(opt);
		Read(a);
		if(opt==1){
	    	Read(b);
	    	Modify(in[a],b);
	    	Modify(out[a]+1,-b);
		}else{
	    	printf("%lld\n",GetSum(out[a])-GetSum(in[a]-1)+sum[out[a]]-sum[in[a]-1]);
		}
    }
    return 0;
}

树链剖分

树链剖分，即将树剖分成若干条链，这里讲的树链剖分为重链剖分。
将每个点的儿子分为两类，子树大小最大的重儿子和其他轻儿子。由重儿子们连成的链称为重链，轻儿子到其父节点的边称为轻边。显然一个节点到根节点的路径上会交替经过若干条重链和轻边。在一棵 n n n 个节点的树上，从一个点到根节点的路径上每经过一条轻边，由于目前在轻儿子，所以就会使目前到达的点的子树大小至少翻一倍。因此一条树链上只会有 O ( l o g 2 n ) O(log_2n) O(log2​n) 条重链。对于每个点，记录点的深度、子树大小、父节点、重儿子、所在重链的顶部即可。
预处理时间复杂度 O ( n ) O(n) O(n)。
树链剖分预处理代码：

int h[N],sz[N],dep[N],f[N],Top[N];
vector<int>G[N];
void PreDFS(int x){
    dep[x]=dep[f[x]]+1;
    sz[x]=1;
    for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		PreDFS(*T);
		if(sz[*T]>sz[h[x]]){
	    	h[x]=*T;
		}
    }
}
void ReDFS(int x,int t){
    Top[x]=t;
    if(h[x]!=0){
		ReDFS(h[x],t);
		for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		    if(*T!=h[x]){
				ReDFS(*T,*T);
		    }
		}
    }
}

求最近公共祖先
求任意两点的最近公共祖先，先判断两点是否在同一条重链上，即判断所在重链顶是否相同。否则，将重链顶深度更深的点移至重链顶的父节点，然后循环下去。
时间复杂度 O ( l o g 2 n ) O(log_2n) O(log2​n)。
求最近公共祖先模板：

int GetLCA(int x,int y){
    while(Top[x]!=Top[y]){
		if(dep[Top[x]]>dep[Top[y]]){
		    x=f[Top[x]];
		}else{
		    y=f[Top[y]];
		}
    }
    return dep[x]<dep[y]?x:y;
}

链修改,点查询
树链 x x x 到 y y y 的修改，可以等价为点 x x x、 y y y、 l c a x , y lca_{x,y} lcax,y​、 l c a x , y lca_{x,y} lcax,y​ 父节点到根的链的四次修改。将点到根链的修改改为单点修改，单点查询改为子树查询。在树链剖分的基础上加上DFS序，并用树状数组优化。
时间复杂度 O ( n + q l o g 2 n ) O(n+qlog_2n) O(n+qlog2​n)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define N 1000001
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    bool tag=false;
    while(t<48||t>57){
    	if(t=='-'){
    	    tag=true;
		}
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
    if(tag==true){
    	x=-x;
    }
}
int t[N],h[N],sz[N],dep[N],f[N],in[N],out[N],Top[N],ct;
vector<int>G[N];
I void PreDFS(int x){
    dep[x]=dep[f[x]]+1;
    sz[x]=1;
    for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		PreDFS(*T);
		if(sz[*T]>sz[h[x]]){
		    h[x]=*T;
		}
    }
}
I void ReDFS(int x,int t){
    Top[x]=t;
    ct++;
    in[x]=ct;
    if(h[x]!=0){
		ReDFS(h[x],t);
		for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		    if(*T!=h[x]){
				ReDFS(*T,*T);
		    }
		}
    }
    out[x]=ct;
}
I int GetLCA(int x,int y){
    while(Top[x]!=Top[y]){
		if(dep[Top[x]]>dep[Top[y]]){
		    x=f[Top[x]];
		}else{
		    y=f[Top[y]];
		}
    }
    return dep[x]<dep[y]?x:y;
}
L c[N];
I void Modify(int x,const int d){
    for(R i=x;i<N;i+=i&-i){
		c[i]+=d;
    }
}
I L GetSum(int x){
    L res=0;
    for(R i=x;i!=0;i&=i-1){
		res+=c[i];
    }
    return res;
}
int main(){
    int n,q;
    Read(n);
    Read(q);
    for(R i=1;i<=n;i++){
		Read(t[i]);
    }
    for(int i=2;i<=n;i++){
    	Read(f[i]);
	    G[f[i]].push_back(i);
    }
    PreDFS(1);
    ReDFS(1,1);
    for(R i=0;i!=q;i++){
		int opt,a;
		Read(opt);
		Read(a);
		if(opt==1){
		    int b,c,lca;
		    Read(b);
		    Read(c);
		    lca=GetLCA(a,b);
		    Modify(in[a],c);
		    Modify(in[b],c);
		    Modify(in[lca],-c);
		    lca=f[lca];
		    if(lca!=0){
				Modify(in[lca],-c);
		    }
		}else{
		    printf("%lld\n",GetSum(out[a])-GetSum(in[a]-1)+t[a]);
		}
    }
    return 0;
}

点修改,链查询
同样地，将树链改为四条点到根的链。点修改，其实是对子树内的点到根的链的和的修改。链查询改为点查询。还是使用树状数组。
时间复杂度 O ( n + q l o g 2 n ) O(n+qlog_2n) O(n+qlog2​n)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define N 1000001
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    bool tag=false;
    while(t<48||t>57){
    	if(t=='-'){
    	    tag=true;
		}
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
    if(tag==true){
    	x=-x;
    }
}
vector<int>G[N];
int t[N],h[N],sz[N],dep[N],f[N],in[N],out[N],Top[N],ct;
L c[N],dis[N];
I void PreDFS(int x){
    dep[x]=dep[f[x]]+1;
    dis[x]=dis[f[x]]+t[x];
    sz[x]=1;
    for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		PreDFS(*T);
		if(sz[*T]>sz[h[x]]){
		    h[x]=*T;
		}
    }
}
I void ReDFS(int x,int t){
    Top[x]=t;
    ct++;
    in[x]=ct;
    if(h[x]!=0){
        ReDFS(h[x],t);
		for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		    if(*T!=h[x]){
				ReDFS(*T,*T);
		    }
		}
    }
    out[x]=ct;
}
I int GetLCA(int x,int y){
    while(Top[x]!=Top[y]){
        if(dep[Top[x]]>dep[Top[y]]){
		    x=f[Top[x]];
		}else{
		    y=f[Top[y]];
		}
    }
    return dep[x]<dep[y]?x:y;
}
I void Modify(int x,const int d){
    for(R i=x;i<N;i+=i&-i){
		c[i]+=d;
    }
}
I L GetSum(int x){
    L res=0;
    for(R i=x;i!=0;i&=i-1){
		res+=c[i];
    }
    return res;
}
int main(){
    int n,q;
    Read(n);
    Read(q);
    for(R i=1;i<=n;i++){
		Read(t[i]);
    }
    for(int i=2;i<=n;i++){
		Read(f[i]);
		G[f[i]].push_back(i);
    }
    PreDFS(1);
    ReDFS(1,1);
    for(R i=0;i!=q;i++){
		int opt,a,b;
		Read(opt);
		Read(a);
		Read(b);
		if(opt==1){
		    Modify(in[a],b);
		    Modify(out[a]+1,-b);
		}else{
		    int lca=GetLCA(a,b);
		    printf("%lld\n",GetSum(in[a])+GetSum(in[b])-GetSum(in[lca])-GetSum(in[f[lca]])+dis[a]+dis[b]-dis[lca]-dis[f[lca]]);
		}
    }
    return 0;
}

链修改,子树查询
链修改，还是改为四次单点修改。修改某点到根的链时，会对该点到根路径上的所有点答案造成影响。具体地说来，若将点 i i i 到根的路径上所有点增加了 d i d_i di​，则点 u u u 子树的和增加量为 ∑ v d v ( d e p v − d e p u + 1 ) \sum_v d_v(dep_v-dep_u+1) ∑v​dv​(depv​−depu​+1)，其中点 v v v 在 u u u 子树中。变形得到 ∑ v d v d e p v − ( d e p u − 1 ) ∑ v d v \sum_v d_v dep_v-(dep_u-1)\sum_{v}d_v ∑v​dv​depv​−(depu​−1)∑v​dv​。因此树状数组维护 d d d 的线性和和 d ⋅ d e p d·dep d⋅dep 的和。
时间复杂度 O ( n + q l o g 2 n ) O(n+qlog_2n) O(n+qlog2​n)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define N 1000001
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    bool tag=false;
    while(t<48||t>57){
    	if(t=='-'){
    	    tag=true;
		}
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
    if(tag==true){
    	x=-x;
    }
}
vector<int>G[N];
int h[N],dep[N],t[N],in[N],out[N],f[N],Top[N],sz[N],pos[N],ct;
L sum[N],c1[N],c2[N];
I void PreDFS(int x){
    dep[x]=dep[f[x]]+1;
    sz[x]=1;
    for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		PreDFS(*T);
		sz[x]+=sz[*T];
		if(sz[*T]>sz[h[x]]){
		    h[x]=*T;
		}
    }
}
I void ReDFS(int x){
    ct++;
    in[x]=ct;
    pos[ct]=x;
    if(h[x]!=0){
		Top[h[x]]=Top[x];
		ReDFS(h[x]);
		for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		    if(*T!=h[x]){
				Top[*T]=*T;
				ReDFS(*T);
		    }
		}
    }
    out[x]=ct;
}
I int GetLCA(int x,int y){
    while(Top[x]!=Top[y]){
		if(dep[Top[x]]>dep[Top[y]]){
		    x=f[Top[x]];
		}else{
		    y=f[Top[y]];
		}
    }
    return dep[x]<dep[y]?x:y;
}
I void Modify(int x,const int d){
    L tem=(L)d*dep[x];
    for(R i=in[x];i<N;i+=i&-i){
		c1[i]+=d;
		c2[i]+=tem;
    }
}
I L GetAns(int x){
    L res1=0,res2=0;
    for(R i=out[x];i!=0;i&=i-1){
		res1+=c1[i];
		res2+=c2[i];
    }
    for(R i=in[x]-1;i!=0;i&=i-1){
		res1-=c1[i];
		res2-=c2[i];
    }
    return res2-res1*(dep[x]-1);
}
int main(){
    int n,q,opt,a,b,c,lca;
    Read(n);
    Read(q);
    for(R i=1;i<=n;i++){
		Read(t[i]);
    }
    for(int i=2;i<=n;i++){
		Read(f[i]);
		G[f[i]].push_back(i);
    }
    PreDFS(1);
    Top[1]=1;
    ReDFS(1);
    for(R i=1;i<=n;i++){
		sum[i]=sum[i-1]+t[pos[i]];
    }
    for(R i=0;i!=q;i++){
		Read(opt);
		Read(a);
		if(opt==1){
		    Read(b);
		    Read(c);
		    lca=GetLCA(a,b);
		    Modify(a,c);
		    Modify(b,c);
		    Modify(lca,-c);
		    if(lca!=1){
				Modify(f[lca],-c);
		    }
		}else{
		    printf("%lld\n",GetAns(a)+sum[out[a]]-sum[in[a]-1]);
		}
    }
    return 0;
}

子树修改,链查询
与前一题同理，子树修改后只会影响子树内的点到根的和。用树状数组维护 d d d 的线性和和 d ⋅ d e p d·dep d⋅dep 的和。
时间复杂度 O ( n + q l o g 2 n ) O(n+qlog_2n) O(n+qlog2​n)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define N 1000001
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    bool tag=false;
    while(t<48||t>57){
    	if(t=='-'){
    	    tag=true;
		}
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
    if(tag==true){
     	x=-x;
    }
}
vector<int>G[N];
int h[N],dep[N],t[N],in[N],out[N],f[N],Top[N],sz[N],pos[N],ct;
L sum[N],c1[N],c2[N];
I void PreDFS(int x){
    dep[x]=dep[f[x]]+1;
    sum[x]=sum[f[x]]+t[x];
    sz[x]=1;
    for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
	  	PreDFS(*T);
	  	sz[x]+=sz[*T];
	  	if(sz[*T]>sz[h[x]]){
	   	    h[x]=*T;
	  	}
    }
}
I void ReDFS(int x){
    ct++;
    in[x]=ct;
    pos[ct]=x;
    if(h[x]!=0){
	  	Top[h[x]]=Top[x];
	  	ReDFS(h[x]);
	  	for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
	   	    if(*T!=h[x]){
	    		Top[*T]=*T;
	    		ReDFS(*T);
	   	    }
	  	}
    }
    out[x]=ct;
}
I int GetLCA(int x,int y){
    while(Top[x]!=Top[y]){
	  	if(dep[Top[x]]>dep[Top[y]]){
	   	    x=f[Top[x]];
	  	}else{
	   	    y=f[Top[y]];
	  	}
    }
    return dep[x]<dep[y]?x:y;
}
I void Modify(int x,const int d){
    L tem=(L)d*dep[x];
    for(R i=in[x];i<N;i+=i&-i){
	   	c1[i]+=d;
	  	c2[i]+=tem;
    }
    for(R i=out[x]+1;i<N;i+=i&-i){
	   	c1[i]-=d;
	  	c2[i]-=tem;
    }
}
I L GetAns(int x){
    L res1=0,res2=0;
    for(R i=in[x];i!=0;i&=i-1){
	  	res1+=c1[i];
	  	res2+=c2[i];
    }
    return res1*(dep[x]+1)-res2+sum[x];
}
int main(){
    int n,q,opt,a,b,lca;
    Read(n);
    Read(q);
    for(R i=1;i<=n;i++){
	  	Read(t[i]);
    }
    for(int i=2;i<=n;i++){
	  	Read(f[i]);
	  	G[f[i]].push_back(i);
    }
    PreDFS(1);
    Top[1]=1;
    ReDFS(1);
    for(R i=0;i!=q;i++){
	  	Read(opt);
	  	Read(a);
	  	Read(b);
	  	if(opt==1){
	   	    Modify(a,b);
	  	}else{
	   	    lca=GetLCA(a,b);
	   	    printf("%lld\n",GetAns(a)+GetAns(b)-GetAns(lca)-GetAns(f[lca]));
	  	}
    }
    return 0;
}

树链剖分除了求最近公共祖先以外，还可以结合数据结构，用数据结构维护重链，以达到快速修改、查询的目的。
链修改,链查询
树链可以被分成许多重链，对每个重链用树状数组维护前缀和，每部分在重链上都是区间查询、区间修改。
时间复杂度 O ( n + q l o g 2 n 2 ) O(n+qlog_2n^2) O(n+qlog2​n2)，空间复杂度 O ( n ) O(n) O(n)。

#include<stdio.h>
#include<vector>
using namespace std;
#define R register int
#define L long long
#define I inline
#define N 1000001
I void Swap(int&x,int&y){
    int tem=x;
    x=y;
    y=tem;
}
char BF[N],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=BF)+fread(BF,1,N,stdin),p1==p2)?0:*p1++)
I void Read(int&x){
    char t=GC;
    x=0;
    bool tag=false;
    while(t<48||t>57){
    	if(t=='-'){
    	    tag=true;
		}
        t=GC;
    }
    while(t>47&&t<58){
        x=(x<<3)+(x<<1)+(t^48);
        t=GC;
    }
    if(tag==true){
    	x=-x;
    }
}
int t[N],h[N],sz[N],dep[N],f[N],in[N],out[N],Top[N],ct;
vector<int>G[N];
I void PreDFS(int x){
    dep[x]=dep[f[x]]+1;
    sz[x]=1;
    for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		PreDFS(*T);
		if(sz[*T]>sz[h[x]]){
		    h[x]=*T;
		}
    }
}
I void ReDFS(int x,int t){
    Top[x]=t;
    ct++;
    in[x]=ct;
    if(h[x]!=0){
		ReDFS(h[x],t);
		for(vector<int>::iterator T=G[x].begin();T!=G[x].end();T++){
		    if(*T!=h[x]){
			ReDFS(*T,*T);
		    }
		}
    }
}
L c1[N],c2[N];
I void Modify(int x,const int d){
    L tem=(L)d*in[x];
    int l=out[Top[x]];
    for(R i=in[x];i<=l;i+=i&-i){
		c1[i]+=d;
		c2[i]+=tem;
    }
}
I L GetSum(int x){
    L res1=0,res2=0;
    int l=in[Top[x]];
    for(R i=in[x];i>=l;i&=i-1){
		res1+=c1[i];
		res2+=c2[i];
    }
    return res1*(in[x]+1)-res2;
}
int main(){
    int n,q,opt,a,b,c;
    Read(n);
    Read(q);
    for(R i=1;i<=n;i++){
		Read(t[i]);
    }
    for(int i=2;i<=n;i++){
    	Read(f[i]);
		G[f[i]].push_back(i);
    }
    PreDFS(1);
    ReDFS(1,1);
    for(R i=1;i<=n;i++){
    	if(in[i]>out[Top[i]]){
		    out[Top[i]]=in[i];
		}
    }
    for(R i=1;i<=n;i++){
		Modify(i,t[i]);
		if(h[i]!=0){
		    Modify(h[i],-t[i]);
		}
    }
    for(R i=0;i!=q;i++){
		Read(opt);
		Read(a);
		Read(b);
		if(opt==1){
		    Read(c);
		    while(Top[a]!=Top[b]){
				if(dep[Top[a]]<dep[Top[b]]){
				    Swap(a,b);
				}
				Modify(Top[a],c);
				if(h[a]!=0){
				    Modify(h[a],-c);
				}
				a=f[Top[a]]; 
		    }
		    if(dep[a]>dep[b]){
				Swap(a,b);
		    }
		    Modify(a,c);
		    if(h[b]!=0){
				Modify(h[b],-c);
		    }
		}else{
		    L ans=0;
		    while(Top[a]!=Top[b]){
				if(dep[Top[a]]<dep[Top[b]]){
				    Swap(a,b);
				}
				ans+=GetSum(a);
				a=f[Top[a]];
		    }
		    if(dep[a]>dep[b]){
				Swap(a,b);
		    }
		    if(Top[a]!=a){
				ans-=GetSum(f[a]);
		    }
		    printf("%lld\n",ans+GetSum(b));
		}
    }
    return 0;
}

总而言之，DFS和树链剖分都可以将树转化为区间，是非常好用的算法。

简单dfs序 + 树链剖分
lifehappy
05-24 574
树链剖分 DFS序 先来讲一讲DFS序是什么东西，直接上图，方便理解。 估计巨巨们应该知道了DFS序的两个重要的东西，in,outin,outin,out数组。 ininin数组就是这个点进入DFS的时间。 outoutout数组就是这个点退出DFS递归栈的时间。 这个时间要注意，当有点进入的时候才加，没有点进入的时候不加也不减。 所以我们发现一个节点的子树的遍历是将，刚好是区间[in,out][in, out][in,out]，所以这里我们就可以通过线段树或者树状数组来维护其子树的节点权值以及节点权
用dfs序维护树结构
ccsu_001的专栏
08-14 3236
给定一棵n个节点的树，m次查询，每次查询需要求出某个节点深度为h的所有子节点。 对于这个问题如果试图去对每个节点保存所有深度的子节点，在数据大的时候内存会吃不消；或者每次查询的时候去遍历一遍，当数据大的时候，时间效率会非常低。 此时如果使用dfs序维护树结构就可以轻松地解决这个问题。 作为预处理，首先将将树的所有节点按深度保存起来，每个深度的所有节点用一个线性结构保存
Housewife Wind POJ2763 （树边权修改+链长查询 ： dfs序+树状数组+lca)
lalalafloat的博客
09-18 223
大致题意 给定一颗有边权的树，支持两种操作，修改某条边的边权，查询从s到某个点距离，初始s的位置给定，后面跟新。 思路 以前我很智障的以为带修改的树上链长只能用树剖做，dfs序只能做子树和…然后最近补网络赛突然发现，修改边权可以把边的权值放到深度较大的点上，因为从根到其他节点的长度，只有这条边深度较深的点以下的子树会受到修改边权的影响。本身从根到叶子的距离就是一个距离的前缀和，把子树映射到dfs序...
DFS序——树链剖分前驱知识
09-20 8630
目录 定义：dfs序：每个节点在dfs深度优先遍历中的进出栈的时间序列。   性质：dfs序可以把一棵树区间化，即可以求出每个节点的管辖区间。 对于一棵树的dfs序而言，同一棵子树所对应的一定是dfs序中连续的一段。 dfs序的七个基本问题： 定义：dfs序：每个节点在dfs深度优先遍历中的进出栈的时间序列。  定义两个数组，in[x]，out[x]。dfs从根结点开始，每个结点分别...
DFS序——解决一类树上数据结构问题的方法
KuribohG
06-07 1908
以下内容有大段摘自《数据结构漫谈》（BY许昊然）
DFS序与树链剖分入门
最新发布
Mark1277的博客
08-22 1060
本文系统介绍了树链剖分算法及其在树结构数据处理中的应用。主要内容包括：1. 基础概念：详细解释了DFS序的定义、性质及其在将树结构转化为线性结构中的作用，包括子树连续性、括号化定理等关键性质。2. 重链剖分：重点阐述了重链剖分的核心思想，通过定义重儿子、轻儿子、重边、轻边等概念，将树分解为O(logn)条重链，实现路径查询的高效处理。3. 算法实现：给出了完整的预处理和查询实现模板，包括两次DFS遍历、线段树维护以及路径/子树更新查询的具体方法。4. 复杂度分析：论证了算法的时间复杂度（预处理O(n)
树链剖分基础
墨染、青衣颜的博客
08-05 355
基本定义 把一棵树分成很多条链，然后利用数据结构（线段树、树状数组等）来维护这些链。 作用 树链剖分用于树路径信息维护。 剖分方式  随便剖分 随机剖分 轻重链剖分（本文） 轻重链剖分的基本概念 重结点：子树结点数目最多的结点； 轻节点：父亲节点中除了重结点以外的结点； 重边：父亲结点和重结点连成的边； 轻边：父亲节点和轻节点连成的边； 重链：由多条...
树链 剖分
angelrobert的博客
04-11 513
重链剖分是将一棵树剖分成若干条重链的一种算法。例如在右图中，1的重儿子为2，5的重儿子为9，其中1，3，4，7，8，11，12都是链顶，1->2->5->9->10->13是一条重链，8自身构成一条重链。
算法学习笔记() DFS序、树链剖分及其应用
memcpy0的博客
12-13 492
本文属于「算法学习」系列文章的汇总目录。之前的「数据结构和算法设计」系列着重于基础的数据结构和算法设计课程的学习，与之不同的是，这一系列主要用来记录大学课程范围之外的高级算法学习、优化与应用的全过程，同时也将归纳总结出简洁明了的算法模板，以便记忆和运用。在本系列学习文章中，为了透彻理解算法和代码，本人参考了诸多博客、教程、文档、书籍等资料，由于精力有限，恕不能一一列出，这里只列示重要资料的不完全参考列表： 算法竞赛进阶指南，李煜东，河南电子音像出版社，GitHub Tedukuri社区以及个人题解文章汇.
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
热门推荐
路人黑的纸巾
10-18 1万+
一篇从浅到深探究一些树上算法的博客
信息学奥赛提高篇：树链剖分测试数据解析
3. DFS序：了解深度优先搜索（DFS）的序号是如何在树链剖分中应用的，以及如何利用DFS序来实现链上查询和更新。 4. 延伸链：学习如何将树上的路径延伸到链上，并且理解如何在链上进行区间查询和更新操作。 5. 常见...
算法学习笔记：树链剖分
Plozia 的小窝
03-09 594
算法学习笔记：树链剖分1. 前言2. 详解 1. 前言 树链剖分，是一种树上的算法，将树划分为若干条链，然后利用线段树来处理树上信息。 在学树链剖分之前，你需要了解的知识： DFS 序。 线段树的基础操作。 2. 详解 模板题：P3384 【模板】轻重链剖分 ...
【洛谷 P3384】树链剖分【详解树链剖分】
lucius-liu.cn
03-15 2756
本文根据一道树链剖分模板题对该算法进行解析。
[论树剖与DFS序的正确姿势]
_Horizon
03-18 1779
树链剖分小结
树状数组上二分
Defener的博客
06-23 3536
树状数组+二分 考虑一个简单的问题，维护一个数组，支持每次修改一个数的值，保证每时每刻每个数都为非负数。每次查询求前缀和kkk lower_bound 的值。 对于修改，可以用树状数组、线段树等数据结构维护。 二分查找 可以在[l,r][l,r][l,r]的范围上二分答案，mid=⌊l+r2⌋mid = \lfloor \frac{l+r}{2} \rfloormid=⌊2l+r​⌋，验证midmidmid的前缀和是否大于kkk，并调整midmidmid。时间复杂度O(log22n)O(log^2_2n)O
联合省选 2020 冰火战士
Defener的博客
06-23 543
冰火战士 题面 每次注册或取消，都是在对应温度值的下标修改能量值。同时维护能量值的前缀和。每次比赛的能量值为冰火能量取最小乘二。随着温度升高，冰队的能量值不会降低，火队的能量值不会升高，具有单调性。因此考虑二分温度。 每次二分都更新答案，若冰队能量值小于火队，则将温度调大；否则将温度调小，并找出某个时能量值最高的温度。但这样二分并不能求出最佳温度。所以需要再次二分温度，此时的温度小于等于之前二分的温度或答案等于实际答案则将温度调大，否则调小。 此题温度规模过大，需要离散化。时间复杂度O(q2log2q)O(
Codeforces 1479 D Odd Mineral Resource
Defener的博客
02-08 398
题面 此题树上不带修，查询路径信息，时限较长，可以树上莫队。利用树上莫队的传统方法，先树分块，对询问排序，然后再执行类似普通莫队的操作即可。但这里的修改操作并不好处理，于是在外层套一分块。每次修改就先修改单点的奇偶性，再修改块内奇数的总数。查询时用普通分块查询方法即可。 时间复杂度 O((n+q)n)O((n+q) \sqrt{n})O((n+q)n​)，空间复杂度 O(n+q)O(n+q)O(n+q) #include<stdio.h> #include<algorithm> #i
线段树优化建图 树上的最短路
Defener的博客
10-27 346
题目描述 题目中树边为双向边，之后增加的边为单向边。 题目要求树上两条链中的点两两连边，显然不能通过。对于链的问题，考虑树剖。将剖出来的重链用线段树优化建图，条链对应 O(log22n)O(log_2^2n)O(log22​n) 个线段树节点，两两连边增加 O(log24n)O(log_2^4n)O(log24​n) 条边，最后跑Dijkstra时间复杂度为 O(mlog25n)O(mlog_2^5n)O(mlog25​n)。 每次加边增加一个点，将第一条链对应的线段树节点连向这个点，再由这个点连向所有第二
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值