DFS序和欧拉序的降维打击

最新推荐文章于 2024-06-14 10:09:26 发布
最新推荐文章于 2024-06-14 10:09:26 发布
阅读量315 收藏 3
点赞数 2
分类专栏： C++编程之美 文章标签： 深度优先 算法 DFS序 欧拉序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y6123236/article/details/134596202
版权

1. DFS 序和时间戳

1.1 DFS 序

定义：树的每一个节点在深度优先遍历中进、出栈的时间序列。

如下树的 dfs 序就是[1,2,8,8,5,5,2,4,3,9,9,3,6,6,4,7,7,1]。

5.png

下图为生成DFS的过程。对于一棵树进行DFS序，除了进入当前节点时对此节点进行记录，同时在回溯到当前节点时对其也记录一下，所以DFS序中一个节点的信息会出现两次。

Tips： 因为在树上深度搜索时可以选择从任一节点开始，所以DFS序不是唯一的。

6.png

DFS序的特点：

  • 可以把树数据结构转换为线性数据结构，从而可以把基于线性数据的算法间接用于处理树上的问题。堪称降维打击。

  • 相同编号之间的节点编号为以此编号为根节点的子树上的所有节点编号。

    [2,8,8,5,5,2]表示编号 2为根节点的子树中所有节点为8,5。

    [4,3,9,9,3,6,6,4]表示编号 4为根节点的子树中所有节点为 3,9,6。

  • 如果一个节点的编号连续相同，则此节点为叶节点。

  • 树的DFS序的长度是2N（N表示节点的数量）。

2.png

求DFS序的代码：

#include <cstdio>
using namespace std;
const int maxn=1e5+10;
int n;
int tot,to[maxn<<1],nxt[maxn<<1],head[maxn];
int id[maxn],cnt;
void add(int x,int y)
{
    to[++tot]=y;
    nxt[tot]=head[x];
    head[x]=tot;
}
void dfs(int x,int f)
{
    id[++cnt]=x;
    for(int i=head[x];i;i=nxt[i])
    {
        int y=to[i];
        if(y==f)
            continue;
        dfs(y,x);
    }
    id[++cnt]=x;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
    }
    dfs(1,0);
    for(int i=1;i<=cnt;i++)
        printf("%d ",id[i]);
    return 0;
}

测试数据：

9
1 2
1 4
1 7
2 8
2 5
4 3
4 6
3 9

1.2 时间戳

按照深度优先遍历的过程，按每个节点第一次被访问的顺序，依次给予这些节点1−N的标记，这个标记就是时间戳。如果一个点的起始时间和终结时间被另一个点包括，这个点肯定是另一个点的子节点（简称括号化定理）。每棵子树 x 在 DFS 序列中一定是连续的一段，结点 x 一定在这段的开头。

7.png

dfs与时间戳的关系，对应列表中索引号和值的关系。

8.png

在dfs代码中添加进入节点时的顺序和离开节点时的顺序。

//……
//in 开始时间 out 结束时间
int in[maxn],out[maxn];
//……
void dfs(int x,int f) {
	//节点的 dfs 序
	id[++cnt]=x;
	//开始时间
	in[x]=cnt;
	for(int i=head[x]; i; i=nxt[i]) {
		int y=to[i];
		if(y==f)
			continue;
		dfs(y,x);
	}
	id[++cnt]=x;
	//结束时间
	out[x]=cnt;
}
//……

3. DFS 序的应用

3.1 割点

什么是割点？

如果去掉一个节点以及与它连接的边，该点原来所在的图被分成两部分，则称该点为割点。如下图所示，删除 2号节点，剩下的节点之间就不能两两相互到达了。例如 4号不能到5号，6号也不能到达1号等等。一个连通分量变成两个连通分量！

9.png

怎么判断图是否存在割点以及如何找出图的割点？

Tarjan 算法是图论中非常实用且常用的算法之一，能解决强连通分量、双连通分量、割点和割边（桥）、求最近公共祖先（LCA）等问题。

Tarjan算法求解割点的核心理念：

  • 在深度优先遍历算法访问到k点时，此时图会被k点分割成已经被访问过的点和没有被访问过的点。
  • 如果k点是割点，则没有被访问过的点中至少会有一个点在不经过k点的情况下，是无论如何再也回不到已访问过的点了。则可证明k点是割点。

下图是深度优先遍历访问到2号顶点的时候。没有被访问到的顶点有4、5、6号顶点。

Tips： 节点边上的数字表示时间戳。

10.png

其中5和6号顶点都不可能在不经过2号顶点的情况下，再次回到已被访问过的顶点(1和3号顶点)，因此2号顶点是割点。

问题变成如何在深度搜索到 k点时判断，没有被访问过的点是否能通过此k或者不能通过此k点回到曾经访问过的点。

算法中引入了回溯值概念。

回溯值表示从当前节点能回访到时间戳最小的祖先，回溯值一般使用名为 low的数组存储，low[i]表示节点 i的回溯值。

如下演示如何初始化以及更新节点的 low值。

  • 定义3 个数组。vis[i]记录节点是否访问过、dfn[i]记录节点的时间戳、low[i]记录节点的回溯值。如下图所示，从 1号节点开始深搜，搜索到4号节点时，3个数组中的值的变化如下。也就是说，初始，节点的 low值和dfn值相同。或者说此时，回溯值还不能确定。

    Tips：注意一个细节，由1->3，认为 1是3的父节点。

11.png

  • 搜索到4号时，与4号相连的边有4->1，4->1是没有访问过的边，且1号节点已经标记过访问过，也就是说通过4号点又回到了1号点。所以说4->1是一条回边，或者说 1-……-4之间存在一个环。则4号点的 low[4]=min( low[4],dfn[1] )=1

12.png

  • 因为 2是4的父节点，显然也是能通过4号点回到1号点，所以也需要更新其low值，更新表达式为 low[2]=min(low[2],low[4])。同理3号点是2号点的父节点，也能通过 3->2->4->1回到1号点。所以3号点的low也需要更新。low[3]=min(low[2],low[3])。

13.png

  • 继续更新5、6号节点的low值。

14.png

根据这些信息，如何判断割点。

  • 如果当前点为根节点时，若子树数量大于一，则说明该点为割点（子树数量不等于与该点连接的边数）。
  • 如果当前点不为根节点，若存在一个儿子节点的low值大于或等于该点的dfn值时（low[子节点] >= dfn[父节点]），该点为割点（即子节点，无法通过回边，到达某一部分节点（这些节点的dfn值小于父亲节点））。这个道理是很好理解的，说明子节点想重回树的根节点是无法绕开父节点。

3.2 割边

定义：即在一个无向连通图中，如果删除某条边后，图不再连通。如下图删除2-5和5-6后，图不再具有连通性。
15.png

删除2-5和5-6边后。

16.png

那么如何求割边呢？

只需要将求割点的算法修改一个符号就可以。只需将low[v]>=num[u]改为low[v]>num[u]，取消一个等于号即可。因为low[v>=num[u]代表的是点v 是不可能在不经过父亲结点u而回到祖先（包括父亲）的，所以顶点u是割点。

如果low[y]和num[x]相等则表示还可以回到父亲，而low[v]>num[u]则表示连父亲都回不到了。倘若顶点v不能回到祖先，也没有另外一条路能回到父亲，那么 w-v这条边就是割边，

3.3 Tarjan 算法

#include <iostream>
#include <string.h>
#include <string>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
const int maxn = 123456;
int n, m, dfn[maxn], low[maxn], vis[maxn], ans, tim;

bool cut[maxn];
vector<int> edge[maxn];

void cut_bri(int cur, int pop) {
	vis[cur] = 1;// 1表示正在访问中
	dfn[cur] = low[cur] = ++tim;
	int children = 0; //子树数量
	for (int i : edge[cur]) { //对于每一条边
		if (i == pop || vis[cur] == 2)
			continue;
		if (vis[i] == 1) //遇到回边
			low[cur] = min(low[cur], dfn[i]); //回边处的更新 (有环)
		if (vis[i] == 0) {
			cut_bri(i, cur);
			children++;  //记录子树数目
			low[cur] = min(low[cur], low[i]); //父子节点处的回溯更新
			if ((pop == -1 && children > 1) || (pop != -1 && low[i] >= dfn[cur])) { //判断割点
				if (!cut[cur])
					ans++;   //记录割点个数
				cut[cur] = true; //处理割点
			}
			if(low[i]>dfn[cur]) { //判断割边
				edge[cur][i]=edge[i][cur]=true;  //low[i]>dfn[cur]即说明(i,cur)是桥(割边)；
			}
		}
	}
	vis[cur] = 2; //标记已访问
}
int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= m; i++) {
		int x, y;
		scanf("%d%d", &x, &y);
		edge[x].push_back(y);
		edge[y].push_back(x);
	}
	for (int i = 1; i <= n; i++) {
		if (vis[i] == 0)
			cut_bri(i, -1); //防止原来的图并不是一个连通块
		//对于每个连通块调用一次cut_bri
	}
	printf("%d\n", ans);
	for (int i = 1; i <= n; i++) //输出割点
		if (cut[i])
			printf("%d ", i);
	return 0;
}

4.欧拉序

定义：进入节点时记录，每次遍历完一个子节点时，返回到此节点记录，得到的 2 ∗ N − 1 长的序列；

欧拉序和DFS序的区别，前者在每一个子节点访问后都要记录自己，后者只需要访问完所有子节点后再记录一次。如下图的欧拉序就是：
1 2 8 2 5 2 1 7 1 4 3 9 3 4 6 4 1。每个点在欧拉序中出现的次数等于这个点的度数，因为DFS到的时候加进一次，回去的时候也加进。

17.png

1.png

性质：

  • 节点 x 第一次出现与最后一次出现的位置之间的节点均为 x 的子节点；

  • 任意两个节点的 LCA 是欧拉序中两节点第一次出现位置中深度最小的节点。两个节点第一次出现的位置之间一定有它们的LCA，并且，这个LCA一定是这个区间中深度最小的点。

根据欧拉序的性质，可以用来求解CLA。如上图，求解 LCA(9,6)。

  • 在欧拉序中找到9和6第一次出现的位置。

18.png

  • 直观比较，知道4号节点是其LCA，特征是9和6之间深度最小的节点。

欧拉序求LCA，先求图的欧拉序、时间戳（可以记录进入和离开节点的时间）以及节点深度。有了这些信息，理论上足以求出任意两点的LCA。变成了典型的RMQ问题。

19.png

为了提升多次查询性能，可以使用ST表根据节点的深度缓存节点的信息。j=0时如下图所示。

20.png

j=1表示区间长度为 2，值为区间长度为 1的两个子区间的深度值小的节点。

21.png

欧拉序求LCA

#include <iostream>
#include <string.h>
#include <string>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
const int maxn = 10000;
int n, m, dfn[maxn], dep[maxn], tim;
int ol[maxn];
int st[maxn][maxn],lg2[maxn];
vector<int> edge[maxn];
void dfs(int cur, int fa) {
	ol[++tim]=cur;
	dfn[cur]=tim;
	dep[cur]=dep[fa]+1;
	for (int v : edge[cur]) { //对于每一条边
		if(v==fa)continue;
		dfs(v,cur);
		ol[++tim]=cur;
	}
}

void stPreprocess() {
	lg2[0] = -1;  // 预处理 lg 代替库函数 log2 来优化常数
	for (int i = 1; i <= (n << 1); ++i) {
		lg2[i] = lg2[i >> 1] + 1;
	}
	for (int i = 1; i <= (n << 1) - 1; ++i) {
		st[i][0] = ol[i];
	}
	for (int j = 1; j <= lg2[(n << 1) - 1]; ++j) {
		for (int i = 1; i + (1 << j) - 1 <= ((n << 1) - 1); ++i) {
			st[i][j] = dep[ st[i] [ j - 1 ] ] < dep[ st[ i + (1 << j - 1)][j - 1 ]    ]  ? st[i][j - 1 ] : st[ i + (1 << j - 1)][j - 1 ];
		}
		cout<<endl;
	}
}

int getlca(int u, int v) {
	if(dfn[u]>dfn[v])swap(u,v);
	u=dfn[u],v=dfn[v];
	int d=lg2[v-u+1];
	int f1=st[ u ][d  ];
	int f2=st[v-(1<<d)+1 ][ d ];
	return dep[f1]<dep[f2]?f1:f2;
}

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= m; i++) {
		int x, y;
		scanf("%d%d", &x, &y);
		edge[x].push_back(y);
		edge[y].push_back(x);
	}
	dfs(1, 0);
	for (int i = 1; i <= 2*n-1; i++) //输出割点
		printf("%d-%d  ", ol[i],dfn[ ol[i] ]);

	stPreprocess();
	int u,v;
	cin>>u>>v;
	int res=getlca(u,v);
	cout<< res;
	return 0;
}

5. 总结

DFS序和欧拉序并不难理解，正如四两拨千斤，却能解决很多复杂的问题。

一枚大果壳
关注
专栏目录
dfs序和欧拉序
小胡同的诗
08-19 734
dfs序 关于dfsdfsdfs序是访问一棵树时将其按照dfsdfsdfs时访问的先后顺序打上序号，一般维护两个数组in和out，用一个id表示时间节点，每次进来一个新的节点则in[u]=++idin[u]=++idin[u]=++id,出去时out[u]=idout[u]=idout[u]=id，当某个结点回溯回来并且没其它结点这个结点的出时间戳一定和最后一个子树的最后一个访问结点的出时间戳一样...
Educational Codeforces Round 85 (Rated for Div. 2) D. Minimum Euler Cycle（字典序最小的欧拉回路）
01-20
构造的欧拉回路是 1 2 1 3 1 4 1 5……1 n 2 3 2 4 2 5……2 n 3 4 3 5……3 n …… n-1 n 1 一共n*(n-1)+1个数 二分取[L,R]的数即可 代码： #include #include #include #include #include #include #include #...
LibreOJ 10135：祖孙询问 ← DFS序 & 欧拉序+LCA+链式前向星
最新发布
hnjzsyjyj的专栏
06-14 780
● 通过 DFS 序可将一棵树映射为一维数组。 ● 假设以某结点 u 为根的子树大小为 cnt[u]，u 在整棵树中的 DFS 序为 dfs[u]，则可得结点 u 的所有子树对应的 DFS 序区间为 [dfs[u],dfs[u]+cnt[u]-1]。 ● 一棵子树所有结点的 DFS 序是整棵树的 DFS 序的连续一段。 ● 借助DFS序，可以快速判断一个结点是否在某子树内。
DFS序
nreyong的博客
12-03 1035
DFS序：每个节点在DFS深度优先遍历中的进出栈的时间序列 树是一种非线性结构，所以对树进行区间操作会很不方便，所以要考虑将树转化成数组形式以便操作 对树进行一趟DFS，同时维护一个时间戳，记录每个结点被访问的时间，可以想象，对同一棵子树上的结点，访问的时间一定是相连的，映射到数组上就是一片连续的区间，如此，对一棵子树进行操作，可以等价于对一片连续的区间进行操作，区间操作常常可以使用树状数组或线段树维护 我们常常需要维护以下信息： Time：时间戳 l[i]：dfs进入子树i的时间 r[i]：.
dfs序（树形结构线性化）
hwdn3000的博客
12-09 1835
通过观察可以发现，以x 为根的子树在一个连续的区间，即在x 入栈和出栈之间，因此，如果要对子树进行操作，可以看作对一个区间进行操作，且这个区间对应新的线性序列中的in[x] out[x]。如对结点B根的子树进行操作，则对应线性序列区间in[B] out[B]，即区间[2,5]进行操作。id[x]：表示结点x在新的线性序列中的下标， id[x]=in[x]。对单个结点x进行修改，则对应新的线性序列对id[x]进行修改。out[x]：表示结点x出栈的时间戳，特殊的，出栈不算时间。
DFS序讲解
qq_35975367的博客
04-07 597
我们经常会遇到树的问题，但树是非线性的结构，操作起来始终还是麻烦，如果我们能把树改造成线性结构，有什么方法？对，就是今天要讲的DSF序； dfs序呢，就是把一棵树区间化，我们用dfs的方式将它区间化。 如图： dfs序就是：ABDDEEBCFHHFG 其实就是用dfs全部遍历一遍，不过我们不能光遍历还有动些小手脚，我们要在遍历的同时记录每个节点进栈与出栈的时间序列。 介绍两个基本函数：in[x],...
2022级图论-欧拉回路和最短路-题解
01-28
在2022级的图论课程中，学生们将深入学习两个核心概念：欧拉回路和最短路径。 **欧拉回路** 欧拉回路是图论中的一个经典概念，它是指从图中的某一点出发，沿着图的边不重复地遍历所有边后恰好回到起点的路径。一个...
St表欧拉序倍增搞LCA.zip_LCA_lca st表_st表
09-25
在这个压缩包中包含的文件“St表欧拉序倍增搞LCA.cpp”很可能是实现了一个基于St表和欧拉序的LCA算法。欧拉序是一种对树节点进行排序的方法，它先深度优先遍历树，记录下访问的顺序，但每次访问一个节点时，先输出其...
破解保险箱(欧拉回路&DFS）
07-11
破解保险箱（欧拉回路&DFS）是一个经典的算法问题，使用欧拉回路和 DFS 可以找到一个最短字符串，使得字符串连续的n位，包含 0~k-1 的所有排列。我们的算法实现了一个基于 DFS 的解决方案，使用贪心算法减少了回溯的...
树的DFS序及其应用
10-20
适用于正在搞OI的选手学习和提高，一种很不错的思想，近年来NOIP考察树上的东西渐多，值得好好学习
DFS序详解
成龙大侠的博客
08-21 7577
转自 ：https://blog.csdn.net/qq_36368339/article/details/79236467 树通常有多种类型，但其终归是非线性结构，操作起来有时总是那么费时。 例如：POJ 3321 给你一棵树，树上每个节点都有1个苹果，然后你对一个节点操作，如果有苹果就拿走，没苹果就放上，然后询问你以x为根的子树上共有多少个苹果。 每次更新都要遍历一遍，查询也要...
dfs序（基础讲解）
LJR的博客
08-27 6222
dfs序简介 dfs序一般用于树状结构中，如图： 图中红色序号为每个点对应的dfs序序号，黑色序号为每个点默认的序号，我称之为节点序序号（下文同） 可见，dfs序如其名，dfs序序号是按照dfs顺序标记的，所以说给每个节点安排上dfs序序号也很简单，只要dfs的时候顺便标上就行了，dfs第多少次就给dfs到的点标为多少。 代码模板 代码如下： //vector<int> node[N]; //int in[N],out[N]; //int Time = 0; //时间戳 void dfs(in
浅谈DFS序
Jr1preg的博客
03-06 1359
DFS序是什么 定义：树的dfs序是一个序列(可以类比前序序列等)，顾名思义，就是在按照dfs时搜到的顺序得到的序列 比如说，来张图 上面这棵树的dfs序为：1 3 2 4 6 7 5 8 10 9 为什么是DFS序 大家可能在想把一棵树转化成一个序列有什么用，在回答这一问题之前，我们先看看dfs序它有什么有用的性质。可以发现，节点uuu的子树在dfs序中为一段连续的区间，那利用dfs序就可以把...
DFS_组合序列
dongdui6736的博客
04-10 200
1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cstdlib> 5 #include <algorithm> 6 #include <vector> 7 #define sc(x)...
树 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:/
DFS序列
weixin_62944148的博客
04-06 693
DFS序是指对一棵树进行DFS时，每个节点被访问到的顺序。DFS序分成两个部分：进入该节点的顺序和退出该节点的顺序。
dfs系列
wk_bjut_edu_cn的博客
06-19 306
组合总和 给定一个无重复元素的数组candidates和一个目标数target，找出candidates中所有可以使数字和为target的组合。 candidates中的数字可以无限制重复被选取。 说明： 所有数字（包括target）都是正整数。 解集不能包含重复的组合。 示例1: 输入: candidates = [2,3,6,7], target = 7, 所...
CodeForces - 782E - 图的dfs序列
H_ang的博客
10-17 250
题目链接：http://codeforces.com/problemset/problem/782/E #include <bits/stdc++.h> using namespace std; vector<int> e[200005], f; bool vis[200005]={0}; void dfs(int u){ vis[u]=1; f.pus...
dfs算法输出欧拉回路
04-28
DFS算法可以用来输出图的欧拉回路，具体实现步骤如下： 1. 选定一个起始节点，开始进行DFS遍历。 2. 在遍历的过程中，对于每个访问过的节点，都将其标记为已访问。 3. 如果当前节点存在未被访问的邻居节点，就将其中一个未被访问的邻居节点作为下一个要访问的节点，并将这条边从图中删除。 4. 如果当前节点不存在未被访问的邻居节点，就将该节点加入到欧拉回路中，并将当前节点退回到上一个节点。 5. 重复以上步骤直到所有的边都被访问。 在实现过程中需要注意一些细节，比如如何判断是否存在欧拉回路，以及如何处理存在孤立点或不连通的情况等。如果有需要的话，我可以进一步解释。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一枚大果壳

码文不易，晚上熬夜需要点咖啡钱

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

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

打赏作者

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

抵扣说明：

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

余额充值