深度优先搜索 | DFS | Depth First Search | C/C++实现

问题描述

在图的搜索算法中，深度优先搜索采取的思路是尽可能地访问相邻顶点。设仍存在未搜索邻接边的顶点中最后一个被发现的顶点为v，那么深度优先搜索就是对顶点v的邻接边递归地进行搜索。当v的边全部搜索完毕后，程序沿发现v时所经过的边回归，继续搜索前一顶点。

搜索一直持续到发现当前起点可到达的所有顶点为止。如果仍有顶点未被发现，则选择其中编号最小的一个作为新起点继续搜索。

深度优先搜索中，需要对各顶点记录以下两个时间戳。
1.$d[v]$:记录第一次访问v的时刻（发现时刻）
2.$f[v]$:记录调查完v的邻接表的时刻（结束时刻）

请基于以下需求编写一个程序，对给定有向图$G=(V,E)$进行深度优先搜索，并显示其执行过程。

1.G以邻接表的形式给出。各顶点编号为1至n
2.各邻接表的顶点编号按升序排列
3.程序报告各顶点的发现时刻和结束时刻
4.深度优先搜索过程中，如果同时出现多个待访问的结点，则选择其中最小的一个进行访问
5.首个被访问的顶点的开始时刻为1

输入： 第1行输入G的顶点数n。接下来n行按如下格式输入各顶点u的邻接表。
u k v1 v2 … vk
其中u为顶点编号，k为u的度，v1 v2 …vk为与u相邻的顶点编号。
输出： 按顶点编号顺序输出各顶点的id、d、f，每个顶点占一行，id、d、f之间用空格隔开。id为顶点编号，d为该顶点的发现时刻，f为该顶点的结束时刻。
限制： 1 ≤ n ≤ 100。

输入示例

6
1 2 2 3
2 2 3 4
3 1 5
4 1 6
5 1 6
6 0

输出示例

1 1 12
2 2 11
3 3 8
4 9 10
5 4 7
6 5 6

讲解

深度优先搜索中，我们用栈来临时保存仍在搜索中的顶点。使用栈的深度优先搜索算法如下。
1.将最初访问的顶点压入栈。
2.只要栈中仍有顶点，就循环进行下述操作：
访问栈顶部的顶点u。
从当前访问的顶点u移动至顶点v时，将v压入栈。如果当前顶点u不存在为访问的相邻顶点，则将u从栈中删除。

用WHITE代表未访问的顶点。
用GRAY代表访问过的顶点。
用BLACK代表访问结束的顶点。
GRAY顶点虽然已经被访问，但仍可能留有通往未访问顶点的边（仍存储在栈中）。相对地，黑色的访问结束的顶点已经没有通往未访问顶点的边了。

使用栈的深度优先搜索需要以下几个变量：
color[n]：用WHITE、GRAY、BLACK中的一个来表示顶点 i 的访问状态。
M[n][n]：邻接矩阵，如果存在顶点 i 到 j 的边，则M[i][j]为true。
Stack S：栈，暂存访问过程中的顶点。

使用这些变量设计的深度优先搜索算法如下：

dfs_init() //顶点编号为0起点
	将所有顶点的color设置为WHITE
	dfs(0)//以顶点0为起点进行深度优先搜索

dfs(u)
	S.push(u)//将起点u压入栈
	color[u] = GRAY//将起点u压入栈
	d[u] = ++time

	while S不为空
		u = S.top()
		v = next(u)//依次获取与u相邻的顶点
		if v != NIL
			if color[v] == WHITE
				color[v] = GRAY
				d[v] = ++time
				S.push(v)
			else
				S.pop()
				color[u] = BLACK
				f[u] = ++time

在通过栈实现的深度优先搜索中，如果需要按照编号顺序访问顶点，那么就要将与u相邻的顶点的访问状态以某种形式保存下来。上述伪代码中，我们用next(u)来按编号顺序获取u的相邻顶点。

相对地，深度优先搜索可以用下述递归算法来简化实现。

dfs_init()//顶点编号为0起点
	将所有顶点的color设置为WHITE
	dfs(0)

dfs(u)
	color[u] = GRAY
	d[u] = ++time
	for 顶点v从0到|V|-1
		if M[u][v] && color[v] == WHITE
			dfs(v)
	color[u] = BLACK
	f[u] = ++time

AC代码如下

1. C（用递归实现的深度优先搜索）

#include<stdio.h>
#define N 100
#define WHITE 0
#define GRAY 1
#define BLACK 2

int n, M[N][N];
int color[N], d[N], f[N], tt;

//用递归函数实现的深度优先搜索
void dfs_visit(int u){
	int v;
	color[u] = GRAY;
	d[u] = ++tt;//最初的访问
	for(v = 0; v < n; v++){
		if(M[u][v] == 0) continue;
		if(color[v] == WHITE){
			dfs_visit(v);
		}
	} 
	color[u] = BLACK;
	f[u] = ++tt;//访问结束 
} 

void dfs(){
	int u;
	//初始化
	for(u = 0; u < n; u++) color[u] = WHITE;
	tt = 0;
	
	for(u = 0; u < n; u++){
		//以未访问的u为起点进行深度优先搜索
		if(color[u] == WHITE) dfs_visit(u); 
	} 
	for(u = 0; u < n; u++){
		printf("%d %d %d\n", u + 1, d[u], f[u]);
	}
} 

int main(){
	int u, v, k, i, j;
	
	scanf("%d", &n);
	for(i = 0; i < n; i++){
		for(j = 0; j < n; j++) M[i][j] = 0;
	}
	
	for(i = 0; i < n; i++){
		scanf("%d %d", &u, &k);
		u--;
		for(j = 0; j < k; j++){
			scanf("%d", &v);
			v--;
			M[u][v] = 1;
		}
	}
	
	dfs();
	
	return 0;
}

2. C++（用栈实现的深度优先搜索）

#include<iostream>
#include<stack>
using namespace std;
static const int N = 100;
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;

int n, M[N][N];
int color[N], d[N], f[N], tt;
int nt[N];

//按编号顺序获取与u相邻的v
int next(int u){
	for(int v = nt[u]; v < n; v++){
		nt[u] = v + 1;
		if(M[u][v]) return v;
	}
	return -1;
} 

//用栈实现的深度优先搜索
void dfs_visit(int r) {
	for(int i = 0; i < n; i++) nt[i] = 0;
	
	stack<int> S;
	S.push(r);
	color[r] = GRAY;
	d[r] = ++tt;
	
	while(!S.empty() ){
		int u = S.top();
		int v = next(u);
		if(v != -1){
			if(color[v] == WHITE){
				color[v] = GRAY;
				d[v] = ++tt;
				S.push(v);
			}
		} else {
			S.pop();
			color[u] = BLACK;
			f[u] = ++tt;
		}
	}
} 

void dfs(){
	//初始化
	for(int i = 0; i < n; i++){
		color[i] = WHITE;
		nt[i] = 0;
	}
	tt = 0;
	
	//以未访问的u为起点进行深度优先搜索
	for(int u = 0; u < n; u++){
		if(color[u] == WHITE) dfs_visit(u);
	} 
	for(int i = 0; i < n; i++){
		cout<<i+1<<" "<<d[i]<<" "<<f[i]<<endl;
	}
} 

int main(){
	int u, k, v;
	
	cin>>n;
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++) M[i][j] = 0;
	}
	
	for(int i = 0; i < n; i++){
		cin>>u>>k;
		u--;
		for(int j = 0; j < k; j++){
			cin>>v;
			v--;
			M[u][v] = 1;
		}
	}
	
	dfs();
	
	return 0;
}