简单易懂DFS(三)dfs剪枝策略

剪枝： 顾名思义，就是通过一些判断，砍掉搜索树上不必要的子树。有时候，我们会发现某个节点对应的子树的状态都不是我们要的结果，那么我们其实没必要对这个分支进行搜索，砍掉这个子树，就是剪枝。

可行性剪枝

还是上篇中提到的一道题：

例1：给定n个整数，要求选出K个数，使得选出来的K个数的和为sum。

所谓可行性剪枝，就是把能够想到的它不可能出现的情况给它剪掉。

对于每一个数，我们有两种选择：选或不选；在这其中，我们用cnt记录了选择数的个数，如果当选择个数cnt==k时，这时再往后选更多的数是没有意义的。所有我们可以直接减去这个搜索分支:

if (cnt > k) {
return;
}

又比如，如果所有的数都是正数，如果一旦发现当前的和值都已经大于sum了，那么之后不管怎么选和值都不可能回到sum，所有当s > sum时，我们也可以直接剪掉：

if (s > sum) {
return;
}

完整实现：

#include <iostream>
using namespace std;
int a[40];
int n, k, sum, ans;
void dfs(int i, int cnt, int s) {
//可行性剪枝
if (cnt > k) {
return;
}
if (s > sum) {
return;
}
if (i == n) {
if (cnt == k && s == sum) {
ans++;
}
return;
}
dfs(i + 1, cnt, s); //不选该数
dfs(i + 1, cnt + 1, s + a[i]); //选择该数
}
int main() {
cin >> n >> k >> sum;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
ans = 0;
dfs(0, 0, 0);
cout << ans << endl;
return 0;
}

最优性剪枝

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

例2:题目：
迷宫游戏
我们用一个二维的字符数组来表示前面画出的迷宫：

S**.
....
***T

其中字符S表示起点，字符T表示终点，字符∗表示墙壁，字符 . 表示平地。你需要从S出发走到T，每次只能向上下左右相邻的位置移动，不能走出地图，也不能穿过墙壁，每个点只能通过一次。你需要编程来求解出从起点到终点的最短路径。

这里的做法就可以像上述描述的一样，先给定一个足够大的数ans，然后如果step>=ans时，则剪掉，因为ans作为当前最优解，即最短路径，而step比ans还要大，再走下去已经没有意义了，所有这样剪枝可以避免无意义的搜索。

if (step >= ans) {
	return;
}

完整实现：

#include <iostream>
#include <string>
using namespace std;

int n, m;
string maze[110];  //地图
bool vis[110][110];  //标记是否访问过
int dir[4][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}}; //方向矩阵
int ans = 100000000;
//判断该点是否在地图内
bool in(int x, int y) {
	return 0 <= x && x < n && 0 <= y && y < m;
}
//dfs
void dfs(int x, int y, int step) {
	//最优性剪枝
	if (step >= ans) {
		return;
	}
	if (maze[x][y] == 'T') {
		ans = step;
		return;
	}
	vis[x][y] = 1;
	//四个方向进行搜索
	for (int i = 0; i < 4; ++i) {
		int tx = x + dir[i][0];
		int ty = y + dir[i][1];
		if (in(tx, ty) && maze[tx][ty] != '*' && !vis[tx][ty]) {
			dfs(tx, ty, step + 1);
		} 
	} 
	vis[x][y] = 0;
}

int main() {
	//输入迷宫地图
	cin >> n >> m;
	for (int i = 0; i < n; ++i) {
		cin >> maze[i];
	}
	int x, y;
	//找到起始点
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < m; ++j) {
			if (maze[i][j] == 'S') {
				x = i, y = j;
			}
		}
	}
	//dfs遍历：找到就输出路径
	dfs(x, y, 0);
	cout << ans << endl;
	return 0;
}

重复性剪枝

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

还是以第一道例题为例：

例3：给定n个整数，要求选出K个数，要求选出K个数的和为sum

先来说说另一种方法：即考虑所有的情况，对于每一种情况进行dfs，，找到符合要求的则ans++

#include <iostream>
using namespace std;
int a[40];
int n, k, sum, ans;
bool xuan[40];
void dfs(int cnt, int s) {
	if (cnt == k && s == sum) {
		ans++;
	}
	for (int i = 0; i < n; ++i) {
		if (!xuan[i]) {
			xuan[i] = 1;
			dfs(cnt + 1, s + a[i]);
			xuan[i] = 0;
		}
	}
}
int main() {
	cin >> n >> k >> sum;
	for (int i = 0; i < n; ++i) {
		cin >> a[i];
	}
	ans = 0;
	dfs(0, 0);
	cout << ans << endl;
	return 0;
}

input:
5 3 9
1 2 3 4 5

对于这样子求出的答案为12，而我们之前测试的结果为2，这是怎么回事呢？仔细观察代码，发现这种方法并没考虑选取数字的顺序，导致选出重复的几个数字，比如（2，3，4）、（3，2，4）这种，那么为了避免这种重复性的搜索，我们则需要进行重复性剪枝：传入一个参数pos，标记选取数字的顺序。

#include <iostream>
using namespace std;
int a[40];
int n, k, sum, ans;
bool xuan[40];
//重复性剪枝
void dfs(int cnt, int s, int pos) {
	//可行性剪枝
	if (cnt > k || s > sum) {
		return;
	}
	if (cnt == k && s == sum) {
		ans++;
	}
	for (int i = pos; i < n; ++i) {
		if (!xuan[i]) {
			xuan[i] = 1;
			dfs(cnt + 1, s + a[i], i + 1);
			xuan[i] = 0;
		}
	}
}
int main() {
	cin >> n >> k >> sum;
	for (int i = 0; i < n; ++i) {
		cin >> a[i];
	}
	ans = 0;
	dfs(0, 0, 0);
	cout << ans << endl;
	return 0;
}

input:
5 3 9
1 2 3 4 5

output:
2

奇偶性剪枝

我们先来看一道题目：

有一个n*m大小的迷宫。其中字符’S’表示起点，字符’D’表示出口，字符’X’表示墙壁，字符’.‘表示平地。你需要从’S’走到’D’,每次只能向上下左右相邻的位置移动，并且不能走出地图，也不能走进墙壁。每次移动消耗1时间，走过路都会塌陷，因此不能走回头路或原地不动。现在已知出口的大门会在T时间打开，判断在0时间从起点出发能否逃离迷宫。
数据范围：m,n<=10,T<=50

对于这道题目，我们只需要用dfs来搜索每条路线，并且只需搜到T时间就可以了。但是仅仅这样也无法通过本题，还需考虑更多的剪枝。

如上图所示，将n * m的网格染成黑白色。我们记每个格子的行数和列数之和为x，如果x为偶数，那么格子就是白色，反之奇数时为黑色。容易发现相邻的两个格子的颜色肯定不一样，也就是说每走一步颜色就会不一样。更普遍的结论：走奇数会改变颜色，走偶数步则颜色不变。

那么如果起点和终点的颜色一样，而T是奇数的话，就不可能离开迷宫。同理，如果终点和起点颜色不一样，而T是偶数的话，那么也不可能逃离迷宫。遇到这两种情况时，就不用进行DFS了，直接输出"NO"; 而这种便是奇偶性剪枝的策略了.

根据上面的思想写出如下的代码：

#include <iostream>
using namespace std;
const int N = 10;
char mp[N][N];
bool vis[N][N];
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
bool ok;
int n, m, T;
void dfs(int x, int y, int t) {
	if (ok) {
		return;
	}
	if (t == T) {
		if (mp[x][y] == 'D') {
			ok = true;
		}
		return;
	}
	vis[x][y] = true;
	for (int i = 0; i < 4; ++i) {
		int tx = x + dx[i];
		int ty = y + dy[i];
		if (tx < 0 || tx >= n || ty < 0 || ty >= m || mp[x][y] == 'X' || vis[tx][ty]) {
			continue;
		}
		dfs(tx, ty, t + 1);
	}
	vis[x][y] = false;
}
int main() {
	cin >> n >> m >> T;
	for (int i = 0; i < n; ++i) {
		cin >> mp[i];
	}
	int sx, sy, ex, ey;  //sx，sy表示起点坐标，ex，ey表示终点坐标
	for (int i = 0; i < n; ++i){
		for (int j = 0; j < m; ++j) {
			if (mp[i][j] == 'S') {
				sx = i, sy = j;
			}
			if (mp[i][j] == 'D') {
				ex = i, ey = j;
			}
		}
	}
	//奇偶性剪枝
	if ((sx + sy + ex + ey + T) % 2 != 0) {
		cout << "NO" << endl;
	} else {
		ok = false;
		dfs(sx, sy, 0);
		if (ok) {
			cout << "YES" << endl;
		} else {
			cout << "NO" << endl;
		}
	}
	return 0;
}

input:
4 4 5
S.X.
…X.
…XD
…

output:
NO