[dfs序基础]系列

最新推荐文章于 2024-06-29 20:50:49 发布
最新推荐文章于 2024-06-29 20:50:49 发布
阅读量260 收藏
点赞数
原文链接：https://www.cnblogs.com/nkxjlym/p/13938494.html
版权

众所周知，dfs序是一个处理子树问题的一个极好工具。dfs序将树形结构转化成线性结构，以快速维护树上点、链、子树等的值。虽然树链剖分的适用性更广，但对于一些卡常题，O(nlog2n)O(nlog2n)的时间复杂度就不算优秀了，所以以下的问题除了最后一道必须树剖外都用的树状数组+dfs序。这篇文章主要是为了总结一下我两天的工程，也记录一下从学长那里学来的卡常技巧。

一、点修改，点查询

？？语法基础可还行

二、点修改、子树查询

转化成线性结构上的点修改，区间查询即可。

#include<cstdio>
#include<cctype>
#define I inline
#define R register int
#define ull unsigned long long
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=GC;}
	n=x*w;
}
using namespace std;
const int maxn=1e6+3;
int n,a[maxn];
struct edge{int to,nxt;}ln[maxn];
int lst[maxn],tt;
I void add(int u,int v)
{
	++tt;
	ln[tt].to=v;
	ln[tt].nxt=lst[u];
	lst[u]=tt;
}
ull c[maxn],sum[maxn];
I void modify(int x,int d){for(R i=x;i<=n;i+=i&-i)c[i]+=d;}
I ull query(R l,R r)
{
	ull ans=0;
	for(;r>l;r&=r-1)ans+=c[r];
	for(;l>r;l&=l-1)ans-=c[l];
	return ans;
}
int dfn[maxn][2],ti;
void dfs(int u)
{
	sum[dfn[u][0]=++ti]=a[u];
	for(R i=lst[u];i;i=ln[i].nxt)dfs(ln[i].to);
	dfn[u][1]=ti;
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(a[i]);
	for(R i=2;i<=n;i++)
	{
		int f;
		read(f);
		add(f,i);
	}
	dfs(1);
	for(R i=1;i<=n;i++)sum[i]+=sum[i-1];
	for(R i=1;i<=n;i++)c[i]=sum[i]-sum[i&i-1];
	for(R i=1;i<=m;i++)
	{
		int op,x,y;
		read(op);
		if(op==1)
		{
			read(x);read(y);
			modify(dfn[x][0],y-a[x]);
			a[x]=y;
		}
		else
		{
			read(x);
			printf("%llu\n",query(dfn[x][0]-1,dfn[x][1]));
		}
	}
	return 0;
}

三、子树修改，点查询

转换成区间修改，点查询即可。

#include<cstdio>
#include<cctype>
#define I inline
#define R register int
#define ull unsigned long long
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=x*10+(ch^48);ch=GC;}
	n=x*w;
}
using namespace std;
const int maxn=1e6+3;
int n;
ull a[maxn];
struct edge{int to,nxt;}ln[maxn];
int lst[maxn],tt;
I void add(int u,int v)
{
	++tt;
	ln[tt].to=v;
	ln[tt].nxt=lst[u];
	lst[u]=tt;
}
ull c[maxn],b[maxn];
I void modify(R l,R r,ull d)
{
	for(;l<r;l+=l&-l)c[l]+=d;
	for(;r<l;r+=r&-r)c[r]-=d;
}
I ull query(R x)
{
	ull ans=0;
	for(;x;x&=x-1)ans+=c[x];
	return ans;
}
int dfn[maxn][2],ti;
void dfs(int u)
{
	b[dfn[u][0]=++ti]=a[u];
	for(R i=lst[u];i;i=ln[i].nxt)dfs(ln[i].to);
	dfn[u][1]=ti+1;
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(a[i]);
	for(R i=2;i<=n;i++)
	{
		int f;
		read(f);
		add(f,i);
	}
	dfs(1);
	for(R i=1;i<=n;i++)c[i]=b[i]-b[i&i-1];
	for(R i=1;i<=m;i++)
	{
		int op,x,y;
		read(op);
		if(op==1)
		{
			read(x);read(y);
			modify(dfn[x][0],dfn[x][1],y);
		}
		else
		{
			read(x);
			printf("%llu\n",query(dfn[x][0]));
		}
	}
	return 0;
}

四、子树修改，子树查询

转换成区间修改，区间查询即可。

#include<cstdio>
#include<cctype>
#include<algorithm>
#define I inline
#define R register int
#define ll long long
using namespace std;
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=x*10+(ch^48);ch=GC;}
	n=x*w;
}
const int N=1e6+3;
int n;
ll a[N];
struct edge{int to,nxt;}ln[N];
int lst[N],tt;
I void add(int u,int v)
{
	++tt;
	ln[tt].to=v;
	ln[tt].nxt=lst[u];
	lst[u]=tt;
}
ll c[N],s[N],vc[N],vs[N];
I void modify(int l,int r,ll d)
{
	ll x=l,y=r;
	for(;l<r;l+=l&-l)c[l]+=d,s[l]+=x*d;
	l=min(l,n+1);
	for(;r<l;r+=r&-r)c[r]-=d,s[r]-=y*d;
	y-=x;
	for(;r<=n;r+=r&-r)s[r]-=y*d;
}
I ll query(int l,int r)
{
	ll ans=0,x=l+1,y=r+1;
	for(;r>l;r&=r-1)ans+=y*c[r]-s[r];
	for(;l>r;l&=l-1)ans-=x*c[l]-s[l];
	y-=x;
	for(;l;l&=l-1)ans+=y*c[l];
	return ans;
}
int dfn[N][2],ti;
void dfs(int u)
{
	dfn[u][0]=++ti;
	vc[ti]=a[u];vs[ti]=(a[u]-vc[ti-1])*ti;
	for(R i=lst[u];i;i=ln[i].nxt)dfs(ln[i].to);
	dfn[u][1]=ti;
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(a[i]);
	for(R i=2;i<=n;i++)
	{
		int f;
		read(f);
		add(f,i);
	}
	dfs(1);
	for(R i=1;i<=n;i++)c[i]=vc[i]-vc[i&i-1];
	for(R i=1;i<=n;i++)vs[i]+=vs[i-1];
	for(R i=1;i<=n;i++)s[i]=vs[i]-vs[i&i-1];
	for(R i=1;i<=m;i++)
	{
		int op,x,y;
		read(op);
		if(op==1)
		{
			read(x);read(y);
			modify(dfn[x][0],dfn[x][1]+1,y);
		}
		else
		{
			read(x);
			printf("%lld\n",query(dfn[x][0]-1,dfn[x][1]));
		}
	}
	return 0;
}

五、点修改，链查询

对于每条链（即路径），我们总是能够拆成链两端的点、lca及lca的父亲到根的四条链。
于是考虑查询点到根的路径。注意到一个点子树内的所有点到根的路径中必然经过这个点，于是从上向下前缀和，于是转化成了子树修改，点查询。

#include<cstdio>
#include<cctype>
#include<algorithm>
#define I inline
#define R register int
#define ull unsigned long long
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=GC;}
	n=x*w;
}
using namespace std;
const int N=1e6+3;
int n,a[N];
struct edge{int to,nxt;}ln[N];
int lst[N],tt;
I void add(int u,int v)
{
	++tt;
	ln[tt].to=v;
	ln[tt].nxt=lst[u];
	lst[u]=tt;
}
ull c[N],b[N];
I void mdf(R l,R r,ull d)
{
	for(;l<r;l+=l&-l)c[l]+=d;
	l=min(l,n+1);
	for(;r<l;r+=r&-r)c[r]-=d;
}
I ull qry(R x)
{
	ull ans=0;
	for(;x;x&=x-1)ans+=c[x];
	return ans;
}
int dfn[N][2],fa[N],dep[N],top[N],son[N],sz[N],ti;
void dfsp(int u)
{
	int mx=0;
	sz[u]=1;
	for(R i=lst[u];i;i=ln[i].nxt)
	{
		int v=ln[i].to;
		dep[v]=dep[u]+1;
		dfsp(v);
		sz[u]+=sz[v];
		if(sz[v]>mx)
		{
			mx=sz[v];
			son[u]=v;
		}
	}
}
void dfsc(int u)
{
	b[dfn[u][0]=++ti]=a[u]+b[dfn[fa[u]][0]];
	if(!top[u])top[u]=u;
	if(son[u])
	{
		top[son[u]]=top[u];
		dfsc(son[u]);
		for(R i=lst[u];i;i=ln[i].nxt)
		{
			int v=ln[i].to;
			if(!dfn[v][0])dfsc(v);
		}
	}
	dfn[u][1]=ti+1;
}
I int glca(int x,int y)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]>dep[top[y]])x=fa[top[x]];
		else y=fa[top[y]];
	}
	return dep[x]<dep[y]?x:y;
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(a[i]);
	for(R i=2;i<=n;i++)
	{
		read(fa[i]);
		add(fa[i],i);
	}
	dfsp(1);dfsc(1);
	for(R i=1;i<=n;i++)c[i]=b[i]-b[i&i-1];
	for(R i=1;i<=m;i++)
	{
		int op,x,y;
		read(op);
		if(op==1)
		{
			read(x);read(y);
			mdf(dfn[x][0],dfn[x][1],y);
		}
		else
		{
			read(x);read(y);
			int l=glca(x,y);
			printf("%llu\n",qry(dfn[x][0])-qry(dfn[l][0])+qry(dfn[y][0])-qry(dfn[fa[l]][0]));
		}
	}
	return 0;
}

六、链修改，点查询

同五，将一条路径拆成四条链，从上向下差分，转化成点修改，子树查询。

#include<cstdio>
#include<cctype>
#include<algorithm>
#define I inline
#define R register int
#define ull unsigned long long
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=GC;}
	n=x*w;
}
using namespace std;
const int N=1e6+3;
int n,a[N];
struct edge{int to,nxt;}ln[N];
int lst[N],tt;
I void add(int u,int v)
{
	++tt;
	ln[tt].to=v;
	ln[tt].nxt=lst[u];
	lst[u]=tt;
}
ull c[N],b[N];
I void mdf(R x,ull d){for(;x<=n;x+=x&-x)c[x]+=d;}
I ull qry(R l,R r)
{
	ull ans=0;
	for(;r>l;r&=r-1)ans+=c[r];
	for(;l>r;l&=l-1)ans-=c[l];
	return ans;
}
int dfn[N][2],fa[N],dep[N],top[N],son[N],sz[N],ti;
void dfsp(int u)
{
	dfn[u][0]=++ti;
	ull p=a[u];
	int mx=0;
	sz[u]=1;
	for(R i=lst[u];i;i=ln[i].nxt)
	{
		int v=ln[i].to;
		dep[v]=dep[u]+1;
		p-=a[v];
		dfsp(v);
		sz[u]+=sz[v];
		if(sz[v]>mx)
		{
			mx=sz[v];
			son[u]=v;
		}
	}
	b[dfn[u][0]]=p;
	dfn[u][1]=ti;
}
void dfsc(int u)
{
	if(!top[u])top[u]=u;
	if(son[u])
	{
		top[son[u]]=top[u];
		dfsc(son[u]);
		for(R i=lst[u];i;i=ln[i].nxt)
		{
			int v=ln[i].to;
			if(v!=son[u])dfsc(v);
		}
	}
}
I int glca(int x,int y)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]>dep[top[y]])x=fa[top[x]];
		else y=fa[top[y]];
	}
	return dep[x]<dep[y]?x:y;
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(a[i]);
	for(R i=2;i<=n;i++)
	{
		read(fa[i]);
		add(fa[i],i);
	}
	dfsp(1);dfsc(1);
	for(R i=1;i<=n;i++)b[i]+=b[i-1];
	for(R i=1;i<=n;i++)c[i]=b[i]-b[i&i-1];
	for(R i=1;i<=m;i++)
	{
		int op,a,b,d;
		read(op);
		if(op==1)
		{
			read(a);read(b);read(d);
			int l=glca(a,b);
			mdf(dfn[a][0],d);mdf(dfn[b][0],d);mdf(dfn[l][0],-d);
			if(fa[l])mdf(dfn[fa[l]][0],-d);
		}
		else
		{
			read(a);
			printf("%llu\n",qry(dfn[a][0]-1,dfn[a][1]));
		}
	}
	return 0;
}

七、链修改，子树查询

直接差分或前缀和好像不好做，那我们推一下式子。
对于u的子树中的一个点v，把v到根加一个值w，对u的贡献为w(depv−depu+1)=w(depv+1)−w⋅depuw(depv−depu+1)=w(depv+1)−w⋅depu
于是分别维护w(depv+1)w(depv+1)和ww的值，点修改，区间查询即可。

#include<cstdio>
#include<cctype>
#include<algorithm>
#define I inline
#define R register int
#define ll long long
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=GC;}
	n=x*w;
}
using namespace std;
const int N=1e6+3;
int n;
ll in[N];
struct edge{int to,nxt;}ln[N];
int lst[N],tt;
I void add(int u,int v)
{
	++tt;
	ln[tt].to=v;
	ln[tt].nxt=lst[u];
	lst[u]=tt;
}
int dfn[N][2],fa[N],dep[N],top[N],son[N],sz[N],ti;
void dfsp(int u)
{
	dfn[u][0]=++ti;
	int mx=0;
	sz[u]=1;
	for(R i=lst[u];i;i=ln[i].nxt)
	{
		int v=ln[i].to;
		dep[v]=dep[u]+1;
		dfsp(v);
		sz[u]+=sz[v];
		in[u]+=in[v];
		if(sz[v]>mx)
		{
			mx=sz[v];
			son[u]=v;
		}
	}
	dfn[u][1]=ti;
}
void dfsc(int u)
{
	if(!top[u])top[u]=u;
	if(son[u])
	{
		top[son[u]]=top[u];
		dfsc(son[u]);
		for(R i=lst[u];i;i=ln[i].nxt)
		{
			int v=ln[i].to;
			if(v!=son[u])dfsc(v);
		}
	}
}
I int glca(int x,int y)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]>dep[top[y]])x=fa[top[x]];
		else y=fa[top[y]];
	}
	return dep[x]<dep[y]?x:y;
}
ll c[N],s[N];
I void mdf(int x,ll d)
{
	ll t=d*(dep[x]+1);
	for(R i=dfn[x][0];i<=n;i+=i&-i)
	{
		c[i]+=d;
		s[i]+=t;
	}
}
I ll qry(int x)
{
	ll a1=0,a2=0;
	R l=dfn[x][0]-1,r=dfn[x][1];
	for(;r>l;r&=r-1)a1+=s[r],a2+=c[r];
	for(;l>r;l&=l-1)a1-=s[l],a2-=c[l];
	return a1-a2*dep[x];
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(in[i]);
	for(R i=2;i<=n;i++)
	{
		read(fa[i]);
		add(fa[i],i);
	}
	dfsp(1);dfsc(1);
	for(R i=1;i<=m;i++)
	{
		int op,a,b,d;
		read(op);
		if(op==1)
		{
			read(a);read(b);read(d);
			int l=glca(a,b);
			mdf(a,d);mdf(b,d);mdf(l,-d);
			if(fa[l])mdf(fa[l],-d);
		}
		else
		{
			read(a);
			printf("%lld\n",qry(a)+in[a]);
		}
	}
	return 0;
}

八、子树修改，链查询

对于v的子树中的一个点u，把v的子树加一个值w，对u的贡献为w(depu−depv+1)=w⋅depu−w(depv−1)w(depu−depv+1)=w⋅depu−w(depv−1)
于是分别维护w(depv−1)w(depv−1)和ww的值，区间修改，点查询即可。

#include<cstdio>
#include<cctype>
#include<algorithm>
#define I inline
#define R register int
#define ll long long
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=GC;}
	n=x*w;
}
using namespace std;
const int N=1e6+3;
int n;
ll in[N];
struct edge{int to,nxt;}ln[N];
int lst[N],tt;
I void add(int u,int v)
{
	++tt;
	ln[tt].to=v;
	ln[tt].nxt=lst[u];
	lst[u]=tt;
}
int dfn[N][2],fa[N],dep[N],top[N],son[N],sz[N],ti;
void dfsp(int u)
{
	dfn[u][0]=++ti;
	int mx=0;
	sz[u]=1;
	for(R i=lst[u];i;i=ln[i].nxt)
	{
		int v=ln[i].to;
		dep[v]=dep[u]+1;
		in[v]+=in[u];
		dfsp(v);
		sz[u]+=sz[v];
		if(sz[v]>mx)
		{
			mx=sz[v];
			son[u]=v;
		}
	}
	dfn[u][1]=ti+1;
}
void dfsc(int u)
{
	if(!top[u])top[u]=u;
	if(son[u])
	{
		top[son[u]]=top[u];
		dfsc(son[u]);
		for(R i=lst[u];i;i=ln[i].nxt)
		{
			int v=ln[i].to;
			if(v!=son[u])dfsc(v);
		}
	}
}
I int glca(int x,int y)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]>dep[top[y]])x=fa[top[x]];
		else y=fa[top[y]];
	}
	return dep[x]<dep[y]?x:y;
}
ll c[N],s[N];
I void mdf(int x,ll d)
{
	ll t=(dep[x]-1)*d;
	R l=dfn[x][0],r=dfn[x][1];
	for(;l<r;l+=l&-l)c[l]+=d,s[l]+=t;
	l=min(l,n+1);
	for(;r<l;r+=r&-r)c[r]-=d,s[r]-=t;
}
I ll qry(int x)
{
	ll a1=0,a2=0;
	for(R i=dfn[x][0];i;i&=i-1)a1+=c[i],a2+=s[i];
	return a1*dep[x]-a2;
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(in[i]);
	for(R i=2;i<=n;i++)
	{
		read(fa[i]);
		add(fa[i],i);
	}
	dfsp(1);dfsc(1);
	for(R i=1;i<=m;i++)
	{
		int op,a,b;
		read(op);
		if(op==1)
		{
			read(a);read(b);
			mdf(a,b);
		}
		else
		{
			read(a);read(b);
			int l=glca(a,b);
			printf("%lld\n",qry(a)+in[a]+qry(b)+in[b]-qry(l)-in[l]-(fa[l]?qry(fa[l])+in[fa[l]]:0));
		}
	}
	return 0;
}

九、链修改，链查询

这道题是唯一不能用dfs序直接搞的，必须用树链剖分。不过我的写法是用的树状数组，为了避免使用vector，用了一些奇技淫巧，充分利用了数组空间。

#include<cstdio>
#include<cctype>
#include<algorithm>
#define I inline
#define R register int
#define ll unsigned long long
char buf[1<<20],*p1,*p2;
#define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
template<class T> I void read(T &n)
{
	char ch=GC;T w=1,x=0;
	while(!isdigit(ch)){if(ch=='-')w=-1;ch=GC;}
	while(isdigit(ch)){x=(x<<3)+(x<<1)+(ch^48);ch=GC;}
	n=x*w;
}
using namespace std;
const int N=1e6+3;
int n,in[N];
struct edge{int to,nxt;}e[N];
int lst[N],tt;
I void add(int u,int v)
{
	++tt;
	e[tt].to=v;
	e[tt].nxt=lst[u];
	lst[u]=tt;
}
int dfn[N],fa[N],dep[N],top[N],son[N],sz[N],ln[N],ti;
void dfsp(int u)
{
	int mx=0;
	sz[u]=1;
	for(R i=lst[u];i;i=e[i].nxt)
	{
		int v=e[i].to;
		dep[v]=dep[u]+1;
		dfsp(v);
		sz[u]+=sz[v];
		if(sz[v]>mx)
		{
			mx=sz[v];
			son[u]=v;
		}
	}
}
void dfsc(int u)
{
	dfn[u]=++ti;
	if(!top[u])top[u]=u;
	if(son[u])
	{
		top[son[u]]=top[u];
		dfsc(son[u]);
		ln[u]=ln[son[u]]+1;
		for(R i=lst[u];i;i=e[i].nxt)
		{
			int v=e[i].to;
			if(!dfn[v])dfsc(v);
		}
	}
	else ln[u]=1;
}
ll c[2][N];
I void mdf(int x,int y,ll d)
{
	int tp=top[x];
	ll *c0=c[0]+dfn[tp]-1,*c1=c[1]+dfn[tp]-1;
	x=dfn[x]-dfn[tp]+1;y=dfn[y]-dfn[tp]+2;
	R l=x,r=y;
	for(;l<r;l+=l&-l)c0[l]+=d,c1[l]+=d*x;
	l=min(l,ln[tp]+1);
	for(;r<l;r+=r&-r)c0[r]-=d,c1[r]-=d*y;
	x-=y;
	for(;r<=ln[tp];r+=r&-r)c1[r]+=d*x;
}
I ll qry(int x,int y)
{
	int tp=top[x];
	ll *c0=c[0]+dfn[tp]-1,*c1=c[1]+dfn[tp]-1;
	x=dfn[x]-dfn[tp];y=dfn[y]-dfn[tp]+1;
	R l=x,r=y;
	ll a0=0,a1=0,a2=0,a3=0;
	for(;r>l;r&=r-1)a1+=c0[r],a0+=c1[r];
	for(;l>r;l&=l-1)a2+=c0[l],a0-=c1[l];
	for(;l;l&=l-1)a3+=c0[l];
	return -a0+a1*(y+1)-a2*(x+1)+a3*(y-x);
}
I void trmdf(int x,int y,ll d)
{
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]])swap(x,y);
		mdf(top[x],x,d);
		x=fa[top[x]];
	}
	if(dep[x]<dep[y])swap(x,y);
	mdf(y,x,d);
}
I ll trqry(int x,int y)
{
	ll ans=0;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]])swap(x,y);
		ans+=qry(top[x],x);
		x=fa[top[x]];
	}
	if(dep[x]<dep[y])swap(x,y);
	return ans+qry(y,x);
}
int main()
{
	int m;
	read(n);read(m);
	for(R i=1;i<=n;i++)read(in[i]);
	for(R i=2;i<=n;i++)
	{
		read(fa[i]);
		add(fa[i],i);
	}
	dfsp(1);dfsc(1);
	for(R i=1;i<=n;i++)c[0][dfn[i]]=in[i];
	for(R i=1;i<=n;i++)
	{
		if(i==top[i])
		{
			int l=ln[i];
			ll *c0=c[0]+dfn[i]-1,*c1=c[1]+dfn[i]-1;
			c1[1]=c0[1];
			for(R j=2;j<=l;j++)c1[j]=c1[j-1]+(c0[j]-c0[j-1])*j;
			for(R j=l;j>1;j--)if(j&j-1)c0[j]-=c0[j&j-1];
			for(R j=l;j>1;j--)if(j&j-1)c1[j]-=c1[j&j-1];
		}
	}
	for(R i=1;i<=m;i++)
	{
		int op,a,b,d;
		read(op);
		if(op==1)
		{
			read(a);read(b);read(d);
			trmdf(a,b,d);
		}
		else
		{
			read(a);read(b);
			printf("%lld\n",trqry(a,b));
		}
	}
	return 0;
}

转载于：https://www.cnblogs.com/nkxjlym/p/13938494.html 

BIT_jzx
关注
7.2.5 蓝桥杯基础数据结构之DFS序
tang7mj的博客
01-29 861
在蓝桥杯等程序设计竞赛中，深度优先搜索（DFS）是一种常用的遍历树或图的方法。DFS序是通过深度优先搜索生成的节点序列，对于解决一系列树上的问题特别有用。本文将介绍DFS序的基本概念、生成方法及其在蓝桥杯中的应用。
算法基础系列第三章——一文详解DFS(全排列演示带入)
weixin_52621323的博客
12-01 2637
对全排列问题的详解，以及对深度优先遍历的生动模拟
双重祖先（DFS序的应用）
我歌月徘徊，我舞影零乱
04-19 531
题面 Dfs序 可以让我们在 线性的数组内 处理树上的子树等问题 所以我们只需要给第一个树 建立DFS序，然后用线段树（或者树状数组）维护一下就好了 样例 第一棵树的DFS序 我们只需要计算第二颗树上，每个点的祖先中，哪些是第一棵树 此节点 也拥有相同祖先的个数。 第二颗树 直接查询 节点 3 的祖先 里 哪些 也是第一棵树的祖先 用线段树 1.对...
dfs序的常见用法整理
LIN452
06-27 4930
dfs序就是一棵树在dfs遍历时组成的节点序列. 它有这样一个特点:一棵子树的dfs序是一个区间. 下面是dfs序的基本代码: void dfs(int x,int pre,int d){//L,R表示一个子树的范围 L[x]=++tot; dep[x]=d; for(int i=0;i<e[x].size();i++){ int y=e[x][i];
DFS序的应用
yiqzq的博客
09-10 345
１.对节点X到Y的最短路上所有点权都加一个数W, 查询某个点的权值 解 : 这个操作等价于 a. 对X到根节点路径上所有点权加W b. 对Y到根节点路径上所有点权加W c. 对LCA(x, y)到根节点路径上所有点权值减W d. 对LCA(x,y)的父节点 parent(LCA(x, y))到根节点路径上所有权值减W 于是要进行四次这样从一个点到根节点的区间修改 将问题进一步简化,...
dfs序及其应用
weixin_44316314的博客
03-23 346
dfs序是用来处理子树一类问题的，可以把子树问题转化为区间问题，以便借助线段树或树状数组处理。根据dfs的顺序来给节点编号，在进入这个节点时更新in数组，出去的时候更新out数组，这样以i为根的子树的操作就可以变成区间[in[i]…out[i]]的操作了。 int in[100005],out[100005]; int tot = 1; void dfs(int x,int fa) { in[...
dfs序的应用及线段树
wrwhahah的博客
05-21 431
http://www.cnblogs.com/stxy-ferryman/p/7741970.html
DFS和BFS以及练习题目
qq_53237241的博客
03-09 1075
温馨提示：学习dfs之前最好先了解一下递归的思想。
C++知识点总结(39)：深度优先搜索（DFS）的剪枝优化
最新发布
joe_g12345的博客
06-29 826
小蓝有一个四方的天平，即天平有四个"臂"，每个"臂"挂着一个盘，只有当四个盘的重量一致时，天平才能平衡，现在给出一些砝码的重量，请你帮小蓝判断一下所给砝码能否使得天平平衡，注意所有的砝码都必须用上。的方阵，方阵上每个位置都有一个数字，表示经过这个位置需要用的时间，小新位于迷雾森林左上角的位置，迷雾森林的出口在右下角，小新只能沿水平方向或垂直方向行走，问小新最快走出迷雾森林的时间？按照最普通的 DFS 迷宫的方法，修改方向、记忆数组的内容。中所有整数的全排列，按照由构成的字典序从小到大输出结果，每组的。
Active Directory 循序渐进系列指南.rar
05-17
《Active Directory 循序渐进系列指南》是一个深入学习和理解Windows操作系统中核心组件——Active Directory（活动目录）的综合教程。本指南旨在帮助IT专业人员逐步掌握如何规划、部署、管理和维护Active Directory...
树的DFS序及其应用
10-20
适用于正在搞OI的选手学习和提高，一种很不错的思想，近年来NOIP考察树上的东西渐多，值得好好学习
DFS序在线段树中的应用 HDU-4578
Zephyr的博客
10-22 417
线段树专题中有一个经典的例子，就是安排工作，题目的大意是，根据输入的关系组建关系树， 但是要用到线段树，必须是区间才能完成的工作，百思不得其解，就去问了万能的度娘，了解到DFS序这种高端的操作，代码不长但是相当给力，瞬间把一个数的根节点 转换成一个区间，这样这个题就成了大家熟悉的线段树区间更新问题，线段树单点查询问题，所以本题的难度也是如何去建立这样一个线段树，由于刚刚接触DFS序所以看不懂也是很正
图论（三）：DFS的应用——拓扑排序与强连通分量
qq_45785407的博客
10-26 3017
本节介绍如何使用DFS对有向无环图进行拓扑排序，以及求强连通分量的算法。 一 拓扑排序 什么是拓扑排序呢？对于一个有向无环图G=(V,E)，拓扑排序是G中所有结点的一种线性次序，满足：如果图G包含边(u,v)，则结点u在拓扑排序中处于结点v的前面。拓扑排序可以理解为一系列要处理的事件的先后的顺序。边(u,v)代表完成v必须先完成u。 注意的是：如果图G包含环路，则不可能排出一个线性次序。下图中，图a表示一个有向无环图，图b表示该图的拓扑序。 ...
算法学习笔记() DFS序、树链剖分及其应用
memcpy0的博客
12-13 437
本文属于「算法学习」系列文章的汇总目录。之前的「数据结构和算法设计」系列着重于基础的数据结构和算法设计课程的学习，与之不同的是，这一系列主要用来记录大学课程范围之外的高级算法学习、优化与应用的全过程，同时也将归纳总结出简洁明了的算法模板，以便记忆和运用。在本系列学习文章中，为了透彻理解算法和代码，本人参考了诸多博客、教程、文档、书籍等资料，由于精力有限，恕不能一一列出，这里只列示重要资料的不完全参考列表： 算法竞赛进阶指南，李煜东，河南电子音像出版社，GitHub Tedukuri社区以及个人题解文章汇.
DFS序
学无止境
05-16 445
DFS序：就是将树形结构转化为线性结构，用dfs遍历一遍这棵树，进入到x节点有一个in时间戳，递归退出时有一个out 时间戳，x节点的两个时间戳之间遍历到的点，就是根为x的子树的所有节点。 问题：求下图的DFS序 #include<iostream> #include<vector> #define max(x,y) (x > y ? x : y) using...
树 DFS序 详解[完全版]
热门推荐
蒟蒻柴犬首相的博客
11-02 2万+
本文是博主通过几篇比较好的博文组合而成。下面是几篇博文的原地址： http://cdnnn.07net01.com/2015/08/899785.html http://blog.youkuaiyun.com/ccsu_001/article/details/47667587 http://blog.youkuaiyun.com/u012061345/article/details/54023285 http:/
青出于蓝胜于蓝 (dfs序 + BIT)
Marcus-Bao的个人主页
03-30 334
传送门思路:        首先一眼dfs序,转化成序列问题来解决这是没有问题的        但是我在如何求徒弟中武功比他高的时候纠结好久。。。其实是我在dfs序中编的号和他给的武功等级让我很混乱了///        这里就运用了树状数组求逆序对的那种思想，我从武功最高的人开始（等级为1的）先看他徒弟的整个区间内是否为0，为0就代表徒弟武功都没他高，然后在把他对应的编号+1（因为我们是按照武功...
DFS 序总结
ZhuRanCheng的博客
05-21 1259
DFS 序总结
DFS序--树的问题转化为区间问题
加载中...
08-17 1112
问题概述：一颗树有n个结点，编号为1到n，其中1为根节点，现有两种操作：1 x y表示将x结点的权值加上y，2 x表 示查询x到根节点中所有结点的权值和，每个结点权值初始都为0，n和m都小于50000 (http://acm.zzuli.edu.cn/zzuliacm/problem.php?cid=1159&pid=2) 输入样例：
零基础算法入门提高资料：精心选购教程
PPT文件具有良好的视觉表现力，通过图片、图表、代码示例和清晰的步骤说明，能够帮助学习者循序渐进地掌握算法知识。 为了帮助大家更好地理解这份资料的知识点，下面我将详细说明算法入门的一些重要知识点： 1. ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值