剪枝: 顾名思义,就是通过一些判断,砍掉搜索树上不必要的子树。有时候,我们会发现某个节点对应的子树的状态都不是我们要的结果,那么我们其实没必要对这个分支进行搜索,砍掉这个子树,就是剪枝。
可行性剪枝
还是上篇中提到的一道题:
例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