一篇文章完全搞懂深度优先搜索（dfs）（含模板以及例题分析）

深度优先搜索

深度优先搜索，简称dfs。我们可以将它跟递归联合在一起。

---

dfs与递归

先回顾一下递归。

我们使用递归完成斐波那契数列的计算：

int fib(int n){
	if(n == 1 || n == 2){
		return 1;	
	}
	return fib(n - 1) + fib(n - 2);
}

以上递归实现斐波那契实际上就是按照深度优先的方式进行搜索。也就是 “一条路走到黑” 。注意：这里的搜索指的是一种穷举方式，把可行的方案都列举出来，不断尝试，直到找到问题的解。

以上即为Fib(5)的计算过程，我们发现实际上对应着一棵树，这棵树被称为搜索树。

深度优先搜索与递归的区别：

1. 深度优先搜索是一种算法，更注重思想。

2. 递归是一种基于编程语言的实现方式。

3. 深度优先搜索可以使用递归实现！当然也就存在非递归的的方式实现搜索。

---

模板

参考了一个大神，模板原文链接如下：https://blog.csdn.net/shineboyxxb/article/details/52200236，这里总结一下。

扫描二维码关注公众号，回复： 10150621 查看本文章

深度优先搜索适合解决必须走到 最深处（例如对于树，须走到它的叶子节点） 才能得到一个解的问题。

通常利用递归实现，所以 每次递归开始的时候要判断是否达到收敛条件，若达到了则得到一个可行解，若没达到，则对当前状态进行扩展（扩展的时候通常会根据实际情况过滤掉一些非法的状态，这个过程叫 剪枝，适当的剪枝有时能极大地提高搜索的速度），如果要求输出具体解，则此时应该保存该状态，当扩展结束后，需要释放这个保存的状态。下面是一个深度优先搜索的编程模板：

 

/**
* dfs 模板.
* @param[in] input 输入数据指针
* @param[inout] cur or gap 标记当前位置或距离目标的距离
* @param[out] path 当前路径，也是中间结果
* @param[out] result 存放最终结果
* @return 路径长度，如果是求路径本身，则不需要返回长度
*/
void dfs(type *input, type *path, int cur or gap, type *result) {
  if (数据非法) return 0; // 终止条件
  if (cur == input.size( or gap == 0)) { // 收敛条件
    将 path 放入 result
  }
  if (可以剪枝) return;
  for(...) { // 执行所有可能的扩展动作
     执行动作，修改 path
     dfs(input, step + 1 or gap--, result);
     恢复 path
  }
}

---

模板应用（经典例题）

N皇后问题

这个题刚接触一定难倒不少人，但真的希望大家别怕，别去逃避，完完全全啃完这篇文章，这题算是秒杀了。

在一个 N × N 的棋盘上放置 N 个皇后，每行刚好放置一个并使其不相互攻击（同一行、同一列、同一斜线上的皇后都是自动攻击），求一共有多少种合法的方法放置 N 个皇后 。

输入格式：输入一个整数N，代表N个皇后。

输出格式：输出一个整数，表示有多少种放置皇后方法。

我们采用逐行放置，当行数为N+1行时，即为终止条件。

那我们如何判断某个位置是否能放置皇后呢？因为我们是逐行放置的，因此在行内是不会产生冲突的，于是我们采用三个数组来记录位置是否可用，分别对应了棋盘的  列、对角线1、对角线2 ，若可用，则标记为0，若不可用，则标记为1。最初的情况是棋盘上所有位置都是可用的，但在我们搜索的过程中，我们每次放置一个皇后的时候就需要占用一个位置，如果我们不对该位置进行标记（标记为已占有），则在下一步放置的过程中就有可能出现违规的情况（同一列、同一斜线）。解释这么多，就是想说明我们在迭代前，一定要修改 列、对角线1、对角线2 的标志！

需要注意的是，列我们可以通过坐标表示，那对角线如何表示呢？

于是，对于对角线1（从右上到左下），我们可以表示为 （行 + 列）；同理，对于对角线2（从左上到右下）可以表示为（行 - 列 + n）。

于是我们可以写出代码：

//8皇后
#include<bits/stdc++.h>
using namespace std;
int n, ans;
bool vy[1005], vd1[1005], vd2[1005];
bool check(int x, int i){
	return !vy[i] && !vd1[x + i] && !vd2[x - i + n];
}
void dfs(int x){
	if(x == n){
		//从0行开始的，所以当 x = n 时候就结束 
		ans++;
		return; 
	}
	for(int i = 0; i < n; i++){
		//每一行内，对列情况讨论（每一个小 path） 
		if(check(x, i)){
			//如果可以放置
			vy[i] = true; 
			vd1[x + i] = true;
			vd2[x - i + n] = true;
			dfs(x + 1); //进行下一行搜素
			//搜索完成后需要释放掉 
			vd1[x + i] = false;
			vd2[x - i + n] = false;
			vy[i] = false; 
		}
	}
}
int main(){
	scanf("%d", &n);
	dfs(0);
	printf("%d", ans);
	return 0;
} 

---

黑白N皇后问题

通过对N皇后的理解，我们对深度优先搜索的讨论以及有一定理解了，接下来看看两个皇后同时摆放的情况。

给定一个n × n 的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入 n 个黑皇后和 n 个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一斜线（正负斜线）上，任意两个白皇后都不在同一行、同一列或同一斜线（正负斜线）上。问共有多少种放法？n 小于等于8。

输入格式：输入第一行为一个整数 n，表示棋盘大小。接下来 n 行，每行 n 个 0 或 1 的整数，如果一个整数为1，表示对应的位置可以放皇后。如果一个整数为0，表示对应的位置不可以放皇后。

输出格式：输出一个整数，表示总共有多少种方法。

黑白N皇后问题实际上跟N皇后很相似，唯一不同的就是多加入了一个皇后。因此我们仅需按顺序解决即可。我们先统一解决黑皇后，然后再解决白皇后。又因为存在有些位置这不能放置的情况，因此在前面八皇后的三个用于判断是否能放置的数组需要进行修改。修改情况如下：

• 0：表示黑、白皇后都能放置
• 1：表示黑皇后不能放置
• 2：表示白皇后不能放置
• 3：表示黑、白皇后都不能放置

并且，我们对dfs函数需要做出调整。多加入一个参数，用于标记对黑皇后操作，还是对白皇后操作。

//黑白
#include<bits/stdc++.h>
using namespace std;
int n, ans; 
int mp[10][10]; //保存棋盘 
int vy[10], vd1[20], vd2[20]; //判断 列、正负对角线是否能放置。 
bool check(int row, int x, int p){
	return mp[row][x] && vy[x] != 3 && vy[x] != p && vd1[row + x] != 3 && vd1[row + x] != p && vd2[row - x + n] != 3 && vd2[row - x + n] != p;
}
void dfs(int row, int p){
	if(row == n && p == 2){
		//中止条件
		ans++;
		return;
	}
	if(row == n){
		//收敛条件，此时黑皇后摆放完成，开始摆放白皇后
		dfs(0, p + 1); 
	}
	for(int i = 0; i < n; i++){
		//对一个行中的每一列讨论
		if(check(row, i, p)){
			//如果p皇后能在这里放置
			mp[row][i] = 0;
			vy[i] += p; 
			vd1[row + i] += p;
			vd2[row - i + n] += p;
			dfs(row + 1, p); //进行下一行遍历，注意：这里的p并没有变化
			//结束后要释放标记位
			vy[i] -= p;
			vd1[row + i] -= p;
			vd2[row - i + n] -= p;
			mp[row][i] = 1;
		} 
	}
}
int main(){
	scanf("%d", &n);
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			scanf("%d", &mp[i][j]);
		}
	}
	dfs(0, 1); //从第0行，黑皇后开始 
	printf("%d", ans); 
	return 0;
}

---

木棍拼三角形问题

蒜头君手上有一些小木棍，它们长短不一，蒜头君想用这些木棍拼出一个等边三角形．并且每根木棍都要用到。例如，林头君手上有长度为 1 , 2 ，3 ，3 的 4 根木棍．他可以让长度为 1 , 2 的木棍组成一条边．另外 2 跟分别组成 2 条边，拼成一个边长为 3 的等边三角形。蒜头君希望你提前告诉他能不能拼出来，免得白费功夫。
输入格式：首先输入一个整数n。（ 3 <=n <=20 ) ，表示木数量，接下来输入 n 根木棍的长度p（ 1 <=p<= 10000 ）。
输出格式：如果蒜头君能拼出等边三角形，输出” yes " ，否则输出“no”。

 

 

由于是等边三角形，因此边长可以一下就判断出来（sum / 3）。接下来，我们逐条边进行拼凑。完成一条边后再进行下一条边的寻找。终止条件是完成三条边的拼凑，因此我们在递归中需要一个参数来记录完成的边数，同时还需要一个参数来记录我们目前的边长和（用来匹配边长），还需要一个参数用来进行索引的推移。

//木棍
#include<bits/stdc++.h>
using namespace std;
int t[10010];
bool vs[10010];
bool f;
int n;
int sum = 0;
void dfs(int cnt, int tot, int index){
	if(f) return;
	if(cnt == 3){
		//完成拼凑 
		f = true;
		return;
	}
	if(tot == sum / 3){
		//完成了一条边，进行下一条 
		dfs(cnt + 1, 0, 0); 
	}
	for(int i = 0; i < n; i++){
		if(!vs[i]){
			//说明可用
			vs[i] = true; 
			dfs(cnt, tot + t[i], i + 1);
			vs[i] = false;
		}
	}
}
int main(){
	scanf("%d", &n);
	for(int i = 0; i < n; i++){
		scanf("%d", &t[i]);
		sum += t[i];
	}
	if(sum % 3 != 0){
		//直接排除
		printf("no\n"); 
		return 0;
	}else{
		dfs(0, 0, 0);
	}
	if(f) printf("yes\n");
	else printf("no\n");
	return 0;
} 

---

数独

是不是已经很有感觉了！其实深度优先搜索的题目并不难，关键找对递归的过程以及终止条件讨论好就行了。常用bool数组来作为访问过的标志。最后练一题。

标准数独是由一个给与了提示数字的 9 × 9 网格组成，我们只需将其空格填上数字，使得每一行，每一列以及每一个 3 × 3 宫都没有重复的数字出现。

输入格式：一个 9 × 9 的数独，数字之间用空格隔开，* 表示需要填写的数字。

输出格式：输出一个 9 × 9 的数独，把输入中的 * 换成需要填写的数字即可。

 

//数独
#include<bits/stdc++.h>
char s[10][10];
bool f; //是否找到
//vx[x][y]——x:第 x 行；y：1-9，有哪些被占用
//vy[x][y]——x:第 x 列；y：1-9，有哪些被占用
//vx[x][y]——x:第 x 个 3*3 的格子；y：1-9，有哪些被占用
bool vx[10][10], vy[10][10], vv[10][10]; //行、列、3*3 能填几 
void dfs(int x, int y){
	if(f) return;
	if(x == 9){
		f = true;
		for(int i = 0; i < 9; i++){
			for(int j = 0; j < 9; j++){
				if(j != 8){
					cout << s[i][j] << " ";
				}else{
					cout << s[i][j] << endl;
				}
			}
		}
		return;
	}
	//换行 
	if(y == 9){
		dfs(x + 1, 0);
		return;
	}
	//本来已经有占位的 
	if(s[x][y] != '*'){
		dfs(x, y + 1);
		return;
	}
	//填写的时候 
	for(int i = 1; i <= 9; i++){
		//对填写内容加上限制 
		if(!vx[x][i] || !vy[y][i] || !vv[i / 3 * 3 + j / 3][i]){
			s[x][y] = '0' + i;
			vx[x][i] = true;
			vy[y][i] = true;
			vv[i / 3 * 3 + j / 3][i] = true;
			dfs(x, y + 1);
			vx[x][i] = false;
			vy[y][i] = false;
			vv[i / 3 * 3 + j / 3][i] = false;
			s[x][y] = '*';
		}
	}
}
int main(){
	//input
	for(int i = 0; i < 9; i++){
		for(int j = 0; j < 9; j++){
			cin >> s[i][j];
		}
	}
	for(int i = 0; i < 9; i++){
		for(int j = 0; j < 9; j++){
			if(s[i][j] != '*'){
				vx[i][s[i][j] - '0'] = true;
				vy[j][s[i][j] - '0'] = true;
				vv[i / 3 * 3 + j / 3][s[i][j] - '0'] = true;
			}
		}
	}
	dfs(0, 0);
	return 0;
}

那么到目前为止，我们练习了这么多题目了，是不是挺有感觉的了？下一步，我们来看看如何通过剪枝减少递归次数。

---

如何剪枝？

剪枝，顾名思义，就是通过一些判断，砍掉搜索树上不必要的子树。我们来看看几种不同的剪枝

可行性剪枝

有时候，我们会发现某个节点对应的子树的状态都不是我们想要的结果，那么我们其实没必要对每个分支都进行搜索，砍掉这个子树。

最优性剪枝

对于求最优解的一类问题，通常可以用最优性剪枝，比如在求迷宫最短路的时候，如果发现当前的步数已经超过了当前最优解，那么从当前状态开始的搜索都是多余的，因为这样搜索下去也找不到最优解了。通过剪枝，可以省去大量冗余的计算。

此外，对于可行性的问题，如前面例题中木棍拼三角形。一旦我们找到了一组可行解，就不再继续进行，这也算最优性剪枝。

重复性剪枝

对于某些特定的搜索方式，一些方案可能会被搜索很多次，这样是没必要的。

如这个问题：

给定  个整数，要求选出  个数，使得选出来的  个数的和为 。

那么在这题中，如果搜索方法是每次从剩下的数里面选一个数，一共搜到第  层，那么 1，2， 3这三个选取方法能被搜索到 6 次，这是没必要的。因此我们只关注选出来的数的和，而根本不关注选出来的数的顺序。因此这里可以使用重复性剪枝。

 我们规定选出来的数的位置是递增的，在搜索的时候，用一个参数来记录上一次选区的数的位置，那么此次我们从这个数之后开始选取，这样最后选出来的方案就不会重复了。

---

来看看例题

引爆炸弹

我们把能够相互引爆的炸弹放到同一个集合中，那么最终划分出集合的个数就是我们要求的答案。显然，引爆一个集合中任意一个炸弹造成的效果都是一样的，我们可以遍历  ×  的方格中所有炸弹，如果当前炸弹没被引爆，那就引爆它，及标记它所在集合中的所有炸弹。

这里有一个剪枝，每行每列最多只搜索一遍，于是可以标记一下搜过的行、列，避免重复性搜索，这样每个格子都最多被检查两遍。

//炸弹
#include<bits/stdc++.h>
using namespace std;
char s[1005][1005];
bool vx[1005], vy[1005]; //表示第n行，和第n列 是否被访问过，因为访问过的话肯定都爆炸了。 
int n, m, cnt;
void dfs(int x, int y){ //相当于进行一次引爆操作。 
	s[x][y] = '0';
	if(!vx[x]){
		vx[x] = true;
		for(int i = 0; i < m; i++){
			if(s[x][i] == '1'){
				dfs(x, i);
			}
		} 
	}
	if(!vy[y]){
		vy[y] = true;
		for(int i = 0; i < m; i++){
			if(s[i][y] == '1'){
				dfs(i, y);
			}
		} 
	}
} 
int main(){
	scanf("%d %d", &n, &m);
	for(int i = 0; i < n; i++){
		scanf("%s", &s[i]);
	}
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			if(s[i][j] == '1'){
				cnt++;
				dfs(i, j);//引爆 
			}
		}
	}
	printf("%d", cnt);
	return 0;
} 

---

那么到这里，其实DFS覆盖的内容就差不多了，剩下的细节还需要大家多多练习，刷题才是硬道理！