基础 DFS序、树链剖分

最新推荐文章于 2021-12-13 04:57:44 发布
最新推荐文章于 2021-12-13 04:57:44 发布
阅读量194 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Defener/article/details/109684538
版权

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和树链剖分都可以将树转化为区间，是非常好用的算法。

Defener
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【树上莫队C++】Count on Tree II（欧拉序降维，树链剖分求最近共同祖先LCA）
qq_73928885的博客
09-22 348
像 `树` 这种二维的如果可以进行降维（将树转化成链处理）处理的话，也可以使用 `莫队算法` 处理。
简单dfs序 + 树链剖分
lifehappy
05-24 508
树链剖分 DFS序 先来讲一讲DFS序是什么东西，直接上图，方便理解。 估计巨巨们应该知道了DFS序的两个重要的东西，in,outin,outin,out数组。 ininin数组就是这个点进入DFS的时间。 outoutout数组就是这个点退出DFS递归栈的时间。 这个时间要注意，当有点进入的时候才加，没有点进入的时候不加也不减。 所以我们发现一个节点的子树的遍历是将，刚好是区间[in,out][in, out][in,out]，所以这里我们就可以通过线段树或者树状数组来维护其子树的节点权值以及节点权
用dfs序维护树结构
ccsu_001的专栏
08-14 3120
给定一棵n个节点的树，m次查询，每次查询需要求出某个节点深度为h的所有子节点。 对于这个问题如果试图去对每个节点保存所有深度的子节点，在数据大的时候内存会吃不消；或者每次查询的时候去遍历一遍，当数据大的时候，时间效率会非常低。 此时如果使用dfs序维护树结构就可以轻松地解决这个问题。 作为预处理，首先将将树的所有节点按深度保存起来，每个深度的所有节点用一个线性结构保存
Housewife Wind POJ2763 （树边权修改+链长查询 ： dfs序+树状数组+lca)
lalalafloat的博客
09-18 175
大致题意 给定一颗有边权的树，支持两种操作，修改某条边的边权，查询从s到某个点距离，初始s的位置给定，后面跟新。 思路 以前我很智障的以为带修改的树上链长只能用树剖做，dfs序只能做子树和…然后最近补网络赛突然发现，修改边权可以把边的权值放到深度较大的点上，因为从根到其他节点的长度，只有这条边深度较深的点以下的子树会受到修改边权的影响。本身从根到叶子的距离就是一个距离的前缀和，把子树映射到dfs序...
DFS序——树链剖分前驱知识
09-20 8329
目录 定义：dfs序：每个节点在dfs深度优先遍历中的进出栈的时间序列。   性质：dfs序可以把一棵树区间化，即可以求出每个节点的管辖区间。 对于一棵树的dfs序而言，同一棵子树所对应的一定是dfs序中连续的一段。 dfs序的七个基本问题： 定义：dfs序：每个节点在dfs深度优先遍历中的进出栈的时间序列。  定义两个数组，in[x]，out[x]。dfs从根结点开始，每个结点分别...
DFS序——解决一类树上数据结构问题的方法
KuribohG
06-07 1809
以下内容有大段摘自《数据结构漫谈》（BY许昊然）
树链剖分基础
墨染、青衣颜的博客
08-05 293
基本定义 把一棵树分成很多条链，然后利用数据结构（线段树、树状数组等）来维护这些链。 作用 树链剖分用于树路径信息维护。 剖分方式  随便剖分 随机剖分 轻重链剖分（本文） 轻重链剖分的基本概念 重结点：子树结点数目最多的结点； 轻节点：父亲节点中除了重结点以外的结点； 重边：父亲结点和重结点连成的边； 轻边：父亲节点和轻节点连成的边； 重链：由多条...
没事找事写算法（1）---浅谈树链剖分及DFS序
fy_23forever的博客
12-24 938
复习 求LCA 树上差分 引入 正题 DFS序 例子 BZOJ4034 树链剖分 例子 求LCA 洛谷P3384树链剖分模板 总结 复习 求LCA LCA（Least Common Ancestors），即最近公共祖先，是指在有根树中，找出某两个结点u和v最近的公共祖先。通常我们会用倍增的方式来进行求解。 树上差分 可以修改一个点到树根的距离，
算法学习笔记() DFS序、树链剖分及其应用
memcpy0的博客
12-13 361
本文属于「算法学习」系列文章的汇总目录。之前的「数据结构和算法设计」系列着重于基础的数据结构和算法设计课程的学习，与之不同的是，这一系列主要用来记录大学课程范围之外的高级算法学习、优化与应用的全过程，同时也将归纳总结出简洁明了的算法模板，以便记忆和运用。在本系列学习文章中，为了透彻理解算法和代码，本人参考了诸多博客、教程、文档、书籍等资料，由于精力有限，恕不能一一列出，这里只列示重要资料的不完全参考列表： 算法竞赛进阶指南，李煜东，河南电子音像出版社，GitHub Tedukuri社区以及个人题解文章汇.
【洛谷 P3384】树链剖分【详解树链剖分】
Gene_I must wait for the sunrise
03-15 2454
题意： 一颗 NNN 个节点的树，每个节点上都有初始权值。现在有四种操作： 操作 111 —— 1&nbsp;x&nbsp;y&nbsp;z1\ x\ y\ z1&nbsp;x&nbsp;y&nbsp;z，表示将 xxx 到 yyy 节点最短路径上所有节点的值加z 操作 222 —— 2&nbsp;x&nbsp;y2\ x\ y2&nbsp;x&nbsp;y，表示求 xxx 到 yyy 节点最短路...
算法学习笔记：树链剖分
Plozia 的小窝
03-09 400
算法学习笔记：树链剖分1. 前言2. 详解 1. 前言 树链剖分，是一种树上的算法，将树划分为若干条链，然后利用线段树来处理树上信息。 在学树链剖分之前，你需要了解的知识： DFS 序。 线段树的基础操作。 2. 详解 模板题：P3384 【模板】轻重链剖分 ...
对LCA、树上倍增、树链剖分（重链剖分&长链剖分）和LCT（Link-Cut Tree）的学习
路人黑的纸巾
10-18 10000
一篇从浅到深探究一些树上算法的博客
[论树剖与DFS序的正确姿势]
_Horizon
03-18 1693
树链剖分小结
Android课程设计 小吃APP.zip
09-08
Android课程设计 小吃APP.zip
数据库课程设计。纯java源码的关系数据库.zip
09-08
数据库课程设计。纯java源码的关系数据库
基于JAVA的企业销售管理系统.zip
最新发布
09-08
基于JAVA的企业销售管理系统设计实现源码，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。 基于JAVA的企业销售管理系统设计实现源码，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。 基于JAVA的企业销售管理系统设计实现源码，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。 基于JAVA的企业销售管理系统设计实现源码，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。
VB002学生成绩管理系统毕业课程设计项目+论文+开题报告
09-08
编号：67 课题研究的主要内容及拟解决的问题。 1•有关学籍等信息的输入，包括输入学生基本信息、所在班级、所学课程和成绩等。 2•学生信息的查询，包括查询学生基本信息、所在班级、已学课程和成绩等。 3•学生信息的修改。 4•班级信息管理的输入，包括输入班级设置、年级信息等。 5•班级信息管理的修改。 6•班级管理信息的查询。 7•学校基本课程信息的输入。 8•基本课程信息的修改。 9•学生课程的设置和修改。 10•学生成绩信息的输入。 11•学生成绩信息的修改。 12•学生成绩信息的查询。 13•学生成绩信息的统计。 针对一般学生管理系统的需求，通过对学生学习过程的内容和数据流程 分析，设计如下面所示的数据项和数据结构： •学生基本信息：包括的数据项有：学生学号、学生姓名、性别、出生日期、班号、联系电话、入学日期、家庭地址、注备等。 •班级信息：包括的数据项有：班号、所在年级等。 •课程基本信息：包括的数据项有：课程号、课程名称、课程类别等。 •课程设置信息：包括的数据项有：年级信息、所学课程等。 •学生成绩信息：包括的数据项有：考试编号、所在班号、学
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值