dfs维护树上信息

最新推荐文章于 2023-04-18 17:06:49 发布
最新推荐文章于 2023-04-18 17:06:49 发布
阅读量316 收藏
点赞数 1
分类专栏： dfs序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sslz_fsy/article/details/82951251
版权

dfs序可以维护树上很多信息

包涵以下几种(较为基本):

1.单点修改,子树查询

2.单点修改,树链查询

3.树链修改,单点查询

4.树链修改,子树和查询

5.子树和修改,树链查询

树链是指树上任意两点构成的路径

1.单点修改,子树查询

//在dfs序上 单点修改,区间查询
//即dfs为下标,这样保证一颗子树对应一个区间,这里用树状数组维护 
#include<bits/stdc++.h>
#define N 100005
#define M 200005
using namespace std;
int first[N],next[M],to[M],tot;
int a[N],st[N],ed[N],c[N<<2],sign;
int n,m,dep[N];
int read(){
	int cnt=0,f=1;char ch=0;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch))cnt=cnt*10+(ch-'0'),ch=getchar();
	return cnt*f;
}
void add(int x,int y){
	next[++tot]=first[x],first[x]=tot,to[tot]=y;
}
void dfs(int u,int f){
	st[u]=++sign;//子树起点
	for(int i=first[u];i;i=next[i]){
		int t=to[i];if(t==f) continue;
		dep[t]=dep[u]+1;
		dfs(t,u);
	}ed[u]=sign;//子树终点
}
void update(int x,int val){for(;x<=n;x+=x&-x) c[x]+=val;}
int quary(int x){int ans=0;for(;x;x-=x&-x) ans+=c[x];return ans;}
int main(){
	n=read(),m=read();;
	for(int i=1;i<=n-1;i++){
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	dep[1]=1,dfs(1,0);
	while(m--){
		int op=read(),x=read();
		if(op==1){int val=read();update(st[x],val);}
		else cout<<quary(ed[x])-quary(st[x]-1)<<endl;
	}return 0;
}

 2.单点修改,树链查询

/*
树链和(x,y) 
为x到根的节点权值和+y到根的节点权值和-lca(x,y)到根的权值和-fa(lca(x,y))到根的权值和
于是变为单点查询 

对于修改a 当b为a的子孙时,a对b有贡献
于是每修改一个a 我们把a的子树都加上一个val

-> 区间修改子树,单点查询 
*/ 
#include<bits/stdc++.h>
#include<cstdio>
#define N 100005
#define M 200005
using namespace std;
int first[N],next[M],to[M],tot;
int a[N],st[N],ed[N],sign;
int n,m,dep[N],fa[N][20];
struct Node{
	int l,r,val,tag;
}t[N<<2];
int read(){
	int cnt=0,f=1;char ch=0;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch))cnt=cnt*10+(ch-'0'),ch=getchar();
	return cnt*f;
}
void add(int x,int y){
	next[++tot]=first[x],first[x]=tot,to[tot]=y;
}
void dfs(int u,int f){
	for(int i=1;i<=18;i++)
		fa[u][i]=fa[fa[u][i-1]][i-1]; 
	st[u]=++sign;
	for(int i=first[u];i;i=next[i]){
		int t=to[i];if(t==f) continue;
		dep[t]=dep[u]+1,fa[t][0]=u;
		dfs(t,u);
	}ed[u]=sign;
}
int lca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	for(int i=18;i>=0;i--)
		if(dep[fa[x][i]]>=dep[y]) x=fa[x][i];
	if(x==y) return x;
	for(int i=18;i>=0;i--)
		if(fa[x][i]!=fa[y][i]) 
			x=fa[x][i],y=fa[y][i];
	return fa[x][0];
}
void build(int o,int l,int r){
	t[o].l=l,t[o].r=r;
	if(l==r) return;
	int mid=(l+r)>>1;
	build(o<<1,l,mid),build(o<<1|1,mid+1,r);
} 
void spread(int o){
	if(t[o].tag){
		t[o<<1].val+=t[o].tag*(t[o<<1].r-t[o<<1].l+1);
		t[o<<1|1].val+=t[o].tag*(t[o<<1|1].r-t[o<<1|1].l+1);
		t[o<<1].tag+=t[o].tag;
		t[o<<1|1].tag+=t[o].tag;
		t[o].tag=0;
	}
}
void update(int o,int L,int R,int val){
	if(L<=t[o].l&&t[o].r<=R){
		t[o].val+=val*(t[o].r-t[o].l+1);
		t[o].tag+=val;return;
	}
	spread(o);
	int mid=(t[o].l+t[o].r)>>1;
	if(L<=mid) update(o<<1,L,R,val);
	if(R>mid) update(o<<1|1,L,R,val);
	t[o].val=t[o<<1].val+t[o<<1|1].val;
}
int quary(int o,int pos){
	if(t[o].l==t[o].r) return t[o].val;
	spread(o);
	int mid=(t[o].l+t[o].r)>>1;
	if(pos<=mid) return quary(o<<1,pos);
	else return quary(o<<1|1,pos);
}
int main(){
	n=read(),m=read();
	build(1,1,n);
	for(int i=1;i<=n-1;i++){
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	dep[1]=1,dfs(1,0);
	while(m--){
		int op=read(),x=read(),y=read();
		if(op==1) update(1,st[x],ed[x],y);
		else{
			int x1=quary(1,st[x]);//x到根的点权和 
			int y1=quary(1,st[y]);//y到根的点权和
			int l=lca(x,y); 
			int l1=quary(1,st[l]);//减去lca到根的点权和
			int l2=quary(1,st[fa[l][0]]);//减去lca's father的
			int ans=x1+y1-l1-l2; 
			cout<<ans<<endl;
		}
	}
}

3.树链修改,单点查询

/*
对于修改a 当b为a的父亲时,a对b有贡献
于是对于查询单点
可以转化为子树节点的贡献和
-> 单点修改,区间查询 
*/ 
#include<bits/stdc++.h>
#include<cstdio>
#define N 100005
#define M 200005
using namespace std;
int first[N],next[M],to[M],tot;
int a[N],st[N],ed[N],sign;
int n,m,dep[N],fa[N][20];
struct Node{
	int l,r,val;
}t[N<<2];
int read(){
	int cnt=0,f=1;char ch=0;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch))cnt=cnt*10+(ch-'0'),ch=getchar();
	return cnt*f;
}
void add(int x,int y){
	next[++tot]=first[x],first[x]=tot,to[tot]=y;
}
void dfs(int u,int f){
	for(int i=1;i<=18;i++)
		fa[u][i]=fa[fa[u][i-1]][i-1]; 
	st[u]=++sign;
	for(int i=first[u];i;i=next[i]){
		int t=to[i];if(t==f) continue;
		dep[t]=dep[u]+1,fa[t][0]=u;
		dfs(t,u);
	}ed[u]=sign;
}
int lca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	for(int i=18;i>=0;i--)
		if(dep[fa[x][i]]>=dep[y]) x=fa[x][i];
	if(x==y) return x;
	for(int i=18;i>=0;i--)
		if(fa[x][i]!=fa[y][i]) 
			x=fa[x][i],y=fa[y][i];
	return fa[x][0];
}
void build(int o,int l,int r){
	t[o].l=l,t[o].r=r;
	if(l==r) return;
	int mid=(l+r)>>1;
	build(o<<1,l,mid),build(o<<1|1,mid+1,r);
} 
void update(int o,int pos,int val){
	if(t[o].l==t[o].r){
		t[o].val+=val;return;
	}
	int mid=(t[o].l+t[o].r)>>1;
	if(pos<=mid) update(o<<1,pos,val);
	else update(o<<1|1,pos,val);
	t[o].val=t[o<<1].val+t[o<<1|1].val;
}
int quary(int o,int L,int R){
	if(L<=t[o].l&&t[o].r<=R) return t[o].val;
	int mid=(t[o].l+t[o].r)>>1,ans=0;
	if(L<=mid) ans+=quary(o<<1,L,R);
	if(R>mid) ans+=quary(o<<1|1,L,R);
	return ans;
}
int main(){
	n=read(),m=read();
	build(1,1,n);
	for(int i=1;i<=n-1;i++){
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	dep[1]=1,dfs(1,0);
	while(m--){
		int op=read(),x=read();
		if(op==1){
			int y=read(),val=read();
			update(1,st[x],val);
			update(1,st[y],val);
			int l=lca(x,y);
			update(1,st[l],-val);
			if(l!=1) update(1,st[fa[l][0]],-val);  
		}
		else cout<<quary(1,st[x],ed[x])<<endl;
	}
}

4.树链修改,子树和查询

/*
同样分成4个 
x对y的贡献 (x在y的子树中)
为 w[x] * (dep[x] - dep[y] + 1) = w[x] * dep[x] - w[x] * (dep[y] - 1) 
所以维护两个线段树 一个维护w[x]的和 一个维护w[x]*dep[x] 

树链修改->单点修改
子树查询-> 区间查w再乘上dep[y],区间查dep[x]*w[x] 
*/
#include<bits/stdc++.h>
#include<cstdio>
#define N 100005
#define M 200005
using namespace std;
int first[N],next[M],to[M],tot;
int a[N],st[N],ed[N],sign;
int n,m,dep[N],fa[N][20];
struct Node{
	int l,r,val;
}t1[N<<2];
struct Node1{
	int l,r,val;
}t2[N<<2];
int read(){
	int cnt=0,f=1;char ch=0;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch))cnt=cnt*10+(ch-'0'),ch=getchar();
	return cnt*f;
}
void add(int x,int y){
	next[++tot]=first[x],first[x]=tot,to[tot]=y;
}
void dfs(int u,int f){
	for(int i=1;i<=18;i++)
		fa[u][i]=fa[fa[u][i-1]][i-1]; 
	st[u]=++sign;
	for(int i=first[u];i;i=next[i]){
		int t=to[i];if(t==f) continue;
		dep[t]=dep[u]+1,fa[t][0]=u;
		dfs(t,u);
	}ed[u]=sign;
}
int lca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	for(int i=18;i>=0;i--)
		if(dep[fa[x][i]]>=dep[y]) x=fa[x][i];
	if(x==y) return x;
	for(int i=18;i>=0;i--)
		if(fa[x][i]!=fa[y][i]) 
			x=fa[x][i],y=fa[y][i];
	return fa[x][0];
}
void build(int o,int l,int r){
	t1[o].l=l,t1[o].r=r; t2[o].l=l,t2[o].r=r;
	if(l==r) return;
	int mid=(l+r)>>1;
	build(o<<1,l,mid),build(o<<1|1,mid+1,r);
} 
void update(int o,int pos,int dep,int val){
	if(t1[o].l==t1[o].r){
		t1[o].val+=val;
		t2[o].val+=val*dep;
		return;
	}
	int mid=(t1[o].l+t1[o].r)>>1;
	if(pos<=mid) update(o<<1,pos,dep,val);
	else update(o<<1|1,pos,dep,val);
	t1[o].val=t1[o<<1].val+t1[o<<1|1].val;
	t2[o].val=t2[o<<1].val+t2[o<<1|1].val; 
}
int quary1(int o,int L,int R){
	if(L<=t1[o].l&&t1[o].r<=R) return t1[o].val;
	int mid=(t1[o].l+t1[o].r)>>1,ans=0;
	if(L<=mid) ans+=quary1(o<<1,L,R);
	if(R>mid) ans+=quary1(o<<1|1,L,R);
	return ans;
}
int quary2(int o,int L,int R){
	if(L<=t2[o].l&&t2[o].r<=R) return t2[o].val;
	int mid=(t2[o].l+t2[o].r)>>1,ans=0;
	if(L<=mid) ans+=quary2(o<<1,L,R);
	if(R>mid) ans+=quary2(o<<1|1,L,R);
	return ans;
}
int main(){
	n=read(),m=read();
	build(1,1,n);
	for(int i=1;i<=n-1;i++){
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	dep[1]=1,dfs(1,0);
	while(m--){
		int op=read(),x=read();
		if(op==1){
			int y=read(),val=read();
			update(1,st[x],dep[x],val);
			update(1,st[y],dep[y],val);
			int l=lca(x,y);
			update(1,st[l],dep[l],-val);
			if(l!=1) update(1,st[fa[l][0]],dep[fa[l][0]],-val);
		}
		else cout<<quary2(1,st[x],ed[x])-(dep[x]-1)*quary1(1,st[x],ed[x])<<endl;
	}return 0;
}

5.子树和修改,树链查询

/*
修改x的权值,当且仅当y在x的子树中时对有贡献
贡献为 w[x] * (dep[y] - dep[x] + 1) = w[x] * (dep[y] + 1) - w[x] * dep[x]
*/ 

#include<bits/stdc++.h>
#include<cstdio>
#define N 100005
#define M 200005
using namespace std;
int first[N],next[M],to[M],tot;
int a[N],st[N],ed[N],sign;
int n,m,dep[N],fa[N][20];
struct Node{
	int l,r,val,tag;
}t1[N<<2];
struct Node1{
	int l,r,val,tag;
}t2[N<<2];
int read(){
	int cnt=0,f=1;char ch=0;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch))cnt=cnt*10+(ch-'0'),ch=getchar();
	return cnt*f;
}
void add(int x,int y){
	next[++tot]=first[x],first[x]=tot,to[tot]=y;
}
void dfs(int u,int f){
	for(int i=1;i<=18;i++)
		fa[u][i]=fa[fa[u][i-1]][i-1]; 
	st[u]=++sign;
	for(int i=first[u];i;i=next[i]){
		int t=to[i];if(t==f) continue;
		dep[t]=dep[u]+1,fa[t][0]=u;
		dfs(t,u);
	}ed[u]=sign;
}
int lca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	for(int i=18;i>=0;i--)
		if(dep[fa[x][i]]>=dep[y]) x=fa[x][i];
	if(x==y) return x;
	for(int i=18;i>=0;i--)
		if(fa[x][i]!=fa[y][i]) 
			x=fa[x][i],y=fa[y][i];
	return fa[x][0];
}
void build(int o,int l,int r){
	t1[o].l=l,t1[o].r=r; t2[o].l=l,t2[o].r=r;
	if(l==r) return;
	int mid=(l+r)>>1;
	build(o<<1,l,mid),build(o<<1|1,mid+1,r);
} 
void spread(int o){
	if(t1[o].tag){
		t1[o<<1].val+=t1[o].tag*(t1[o<<1].r-t1[o<<1].l+1);
		t1[o<<1|1].val+=t1[o].tag*(t1[o<<1|1].r-t1[o<<1|1].l+1);
		t1[o<<1].tag+=t1[o].tag;
		t1[o<<1|1].tag+=t1[o].tag;
		t1[o].tag=0;
	}
	if(t2[o].tag){
		t2[o<<1].val+=t2[o].tag*(t2[o<<1].r-t2[o<<1].l+1);
		t2[o<<1|1].val+=t2[o].tag*(t2[o<<1|1].r-t2[o<<1|1].l+1);
		t2[o<<1].tag+=t2[o].tag;
		t2[o<<1|1].tag+=t2[o].tag;
		t2[o].tag=0;
	}
}
void update(int o,int L,int R,int dep,int val){
	if(L<=t1[o].l&&t1[o].r<=R){
		t1[o].val+=val*(t1[o].r-t1[o].l+1);
		t1[o].tag+=val;
		t2[o].val+=val*dep*(t2[o].r-t2[o].l+1);
		t2[o].tag+=val*dep;
		return;
	}
	spread(o);
	int mid=(t1[o].l+t1[o].r)>>1;
	if(L<=mid) update(o<<1,L,R,dep,val);
	if(R>mid) update(o<<1|1,L,R,dep,val);
	t1[o].val=t1[o<<1].val+t1[o<<1|1].val;
	t2[o].val=t2[o<<1].val+t2[o<<1|1].val; 
}
int quary1(int o,int L,int R){
	if(L<=t1[o].l&&t1[o].r<=R) return t1[o].val;
	spread(o);
	int mid=(t1[o].l+t1[o].r)>>1,ans=0;
	if(L<=mid) ans+=quary1(o<<1,L,R);
	if(R>mid) ans+=quary1(o<<1|1,L,R);
	return ans;
}
int quary2(int o,int L,int R){
	if(L<=t2[o].l&&t2[o].r<=R) return t2[o].val;
	spread(o);
	int mid=(t2[o].l+t2[o].r)>>1,ans=0;
	if(L<=mid) ans+=quary2(o<<1,L,R);
	if(R>mid) ans+=quary2(o<<1|1,L,R);
	return ans;
}
int main(){
	n=read(),m=read();
	build(1,1,n);
	for(int i=1;i<=n-1;i++){
		int x=read(),y=read();
		add(x,y),add(y,x);
	}
	dep[1]=1,dfs(1,0);
	while(m--){
		int op=read(),x=read(),y=read();
		if(op==1){
			update(1,st[x],ed[x],dep[x],y);
		}
		else{
			int ans=0;
			int x1=(dep[x]+1)*quary1(1,st[x],st[x])-quary2(1,st[x],st[x]);
			int y1=(dep[y]+1)*quary1(1,st[y],st[y])-quary2(1,st[y],st[y]);
			int l=lca(x,y);
			int l1=(dep[l]+1)*quary1(1,st[l],st[l])-quary2(1,st[l],st[l]);
			ans=x1+y1-l1;
			if(l!=1) 
                        ans-=(dep[fa[l][0]]+1)*quary1(1,st[fa[l][0]],st[fa[l][0]])-quary2(1,st[fa[l][0]],st[fa[l][0]]);
			cout<<ans<<endl;
		}
	}return 0;
}

总结一下

类型修改的方法答案
1.单点修改,子树查询单点修改区间查询
2.单点修改,树链查询修改整棵子树的值,因为它对整棵子树有贡献4个单点查询
3.树链修改,单点查询树链修改变成4个单点修改

子树(区间)查询,

因为子树中的树链对这个点有影响

4.树链修改,子树和查询同样拆成4个,分别插入两个线段树,一个为w,一个为dep[当前插入的点]*w, 单点修改子树(区间)查询
5.子树和修改,树链查询

子树直接区间修改,一个修改w

另一个修改dep[当前根节点]*w的值

4个单点查询

注意: 所有线段树的下标均为dfs序,因为这样一颗子树对应一整个区间

dfs序的作用就是将树分成一整块一整块的区间,这样就可以线段树维护

 

FSYo
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
DFS 树
malanlllll的的的的的博客
03-27 1万+
翻译自 THe DFS tree and its applications: how I found out I really didn’t understand bridges 介绍 这是一篇对可以用图的 DFS 树来解的题的教程/扩展。 在很长一段时间，我并没有真正理解传统算法是如何找到桥的。很多题解看起来没有真正解释它是如何工作的，很多只是顺带提到它但后迅速地进入实现部分。某一天有人解释了 ...
DFS的树上应用
m0_52711790的博客
01-16 740
本文主要讲了树上的DFS、树的重心、树的直径、拓扑排序与DFS、欧拉路等理论内容。
树链剖分 完全模板（子树查改+树链查改）
平凡人Kalzn的博客
08-28 359
题目链接 以洛谷题为原题。看代码。 下面是模板代码（横线之外的为模板代码）： /*-------------------- 1.mchange(x, y, v) 树链更改（x,y） 2.mask(x, y) 树链查询（x,y） 3.achange(x, v) 子树更改x 4.aask(x) 子树查询x --------------------*/ ...
DFS树
Scar_Halo
06-24 1100
参考：CF1325F Ehab’s Last Theorem（dfs树 简单定义为一颗由 dfsdfsdfs 生成而来的树 一颗 dfsdfsdfs树的边分为树边和非树边 深色的是树边，浅色的是非树边 dfsdfsdfs树的性质： ①：每条非树边 (u,v)(u, v)(u,v) 都连向子树中某个点，且一定具有祖先关系 ②：子树之间不存在非树边 因此 uuu 到 vvv 在树上的链 与 非树边 (u,v)(u, v)(u,v) 可以形成一个环，环的大小为 ∣dep[u]−dep[v]∣+1|dep[u]
DFS在树的遍历中的简单应用（4种遍历的互相求解）
在猴站学算法
04-18 1288
树这种结构，我将在另一篇文章进行介绍。此处只讲解DFS在树的4种遍历中的简单应用，如：对于二叉树，已知先序、中序遍历求后序遍历；已知中序、后序遍历求先序遍历。对于完全二叉树，已知任意一种遍历则可以求出其他遍历。此处使用的存储结构是数组，并不采用树结构。
基于QT实现dfs寻论算法的迷宫可视化
03-06
DFS是一种用于遍历或搜索树或图的算法，它沿着树的深度从根节点开始，探索尽可能深的分支，直到找到解决方案或者遍历完整个图。在迷宫问题中，我们可以将迷宫视为一个二维矩阵，其中1表示墙壁，0表示可通行的路径。...
dfs_tree.rar_ACM_dfs_dfs ACM_vc6.0
09-23
标题中的"dfs_tree.rar_ACM_dfs_dfs ACM_vc6.0"暗示了这是一个关于图论算法的资源包，特别是深度优先搜索（DFS）在解决ACM（国际大学生程序设计竞赛）问题上的应用，并且是为Visual C++ 6.0开发环境准备的。...
DFS查询两结点之间路径
03-11
在计算机科学中，图论是研究网络结构的重要理论，而深度优先搜索（DFS，Depth-First Search）是一种在图或树中遍历节点的算法。DFS通常用于寻找两个节点之间的路径，解决连通性问题，或者找出有向图中的环等。在本...
吉司机线段树吉如一原文
03-02
吉司机线段树的解决思路可以分为两步：首先，对线段树上的每一个区间维护区间最大值mx、次大值se和区间和sum；然后，对于每一次操作，利用DFS算法来更新线段树中的信息，实现快速的区间查询和修改。 吉司机线段树的...
DFS.rar_tim
09-23
3. 在DFS过程中，维护一个反向边的最短距离，这样可以利用回溯信息快速计算出最短路径。 标签“tim”进一步确认了我们的讨论是关于寻找最优解或路径的问题。在图论中，寻找最短路径是一个经典问题，它在路由、网络...
树的DFS序及其应用
10-20
适用于正在搞OI的选手学习和提高，一种很不错的思想，近年来NOIP考察树上的东西渐多，值得好好学习
树上各种DFS姿势算法笔记
weixin_34054931的博客
05-30 250
树是指由n个点，n-1条边构成的联通无向图。如果有一棵树，它的每一条边(u,v)都有一个权值l(u,v)，我们把这样的树称作带权树。 我们知道对于树上的任意两个点，他们之间的路径是唯一的。对于两个点u，v来说，我们可以算出u与v之间的路径上的所有边权之和，将其称作u与v之间路径的长度，记作d(u,v)。 你的任务是计算：∑d(u,v) (u!=v) 【输入文件】 输入文件的第一行为一个正整数n。...
图论复习——dfs树,点双,边双,强连通分量
Edward The Bunny 的博客
10-14 1403
https://blog.csdn.net/weixin_43848437/article/details/105133155 https://www.cnblogs.com/lcfsih/p/14391394.html#/c/subject/p/14391394.html https://blog.aor.sd.cn/archives/418/ http://blog.sina.com.cn/s/blog_64675f540100s4nv.html https://www.cnblogs.com/JiuP
【树上DFS的大问题！！！】
KIKO_caoyue的博客
03-13 245
本文解决了三年以来的疑惑。 三年多来，我写树上dfs的时候只敢写void dfs()。因为每次我写int dfs()准出错。原因是因为：int dfs()是需要返回值层层上传的，而void dfs()搜到了答案那就记录下来。 首先来看代码「在树上求now到1的距离」（注意，这段代码是错误的树上dfs）： int dfs3(int now,int stp) { vis[1][now] = 1; if(now==1) { return stp; }
算法第九期——DFS(深度优先搜索）对树的应用
荷叶田田的博客
01-12 835
利用DFS(深度优先搜索）解决树相关的问题。
BFS树&DFS树
ZigZagK的博客
07-30 4192
ps：接下来讨论的都是无向图。BFS树定义用BFS遍历一张图时得到的树，可能存在非树边。性质非树边只会存在于同层或相邻两层。作用可以将图分层，比较经典的应用是Dinic刷最大流。 其他有什么用啊？不知道啊好像没啥用了。 DFS树定义用DFS遍历一张图时得到的树，可能存在非树边。性质非树边只会连向祖先，不会出现一棵子树连向另一棵子树的情况，因为这违反DFS的规则，如图： 非树边-环我们会发现，D
树 DFS序 详解[完全版]
热门推荐
蒟蒻柴犬首相的博客
11-02 2万+
本文是博主通过几篇比较好的博文组合而成。下面是几篇博文的原地址： http://cdnnn.07net01.com/2015/08/899785.html http://blog.csdn.net/ccsu_001/article/details/47667587 http://blog.csdn.net/u012061345/article/details/54023285 http:/
关于树上信息的维护
Michael_GLF的博客
10-06 603
1.Dfs序的一些奇奇怪怪的操作和改进 所谓dfs序，就是一棵树被 dfs 时所经过的节点的顺序。一般的作用是维护子树信息，如果记录 dfn[i] 表示 i 号点的 dfs 序，sze[i]表示 i 号点的子树大小，那么 x 是 y 的祖先等价于:dfn[y] ∈ [dfn[x], dfn[x]+sze[x]−1] 那么我们就可以利用dfs序来进行一些树上的操作： 1.维护一棵树，支持：子树...
历届试题 网络寻路
chenchukun的专栏
02-13 1638
历届试题 网络寻路   时间限制：1.0s   内存限制：256.0MB        问题描述 X 国的一个网络使用若干条线路连接若干个节点。节点间的通信是双向的。某重要数据包，为了安全起见，必须恰好被转发两次到达目的地。该包可能在任意一个节点产生，我们需要知道该网络中一共有多少种不同的转发路径。 源地址和目标地址可以相同，但中间节点必须不同。 如
dfs函数
最新发布
05-26
DFS（Depth First Search，深度优先搜索）是一种用于遍历或搜索树或图的算法。它从根节点开始，沿着一条路径直到无法再继续为止，然后回溯到上一个节点，继续沿着另一条路径进行搜索。DFS 通常使用递归来实现。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FSYo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值