c语言中dfs用pos做参数,简单易懂DFS(三)dfs剪枝策略

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

可行性剪枝

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

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

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

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

if (cnt > k) {

return;

}

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

if (s > sum) {

return;

}

完整实现：

#include 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 #include 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 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 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 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