深度优先搜索是一种搜索策略，但是他是通过递归（或循环）来实现的，那么时间复杂度便不会低。通过dfs，我们可以得到一颗搜索树，但实际上这棵树的许多枝条是不需要的，那么我们没必要对这个分支进行搜索，砍掉这个子树，便是剪枝。
1.可行性剪枝
如果当前条件不合法就不再继续搜索，直接return。这是非常好理解的剪枝。
问题：给定n个数，要求选出k个数，使得选出的数和为sum。
代码如下：
import java.util.Scanner;
public class L1 {
static int n, k, sum, ans = 0;
static int[] a = new int[1005];
static void dfs(int i, int cnt, int s) {
if (cnt > k)// 限制条件1，选的个数超过k
return;
if (s > sum)// 限制条件2，和大于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]);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
k = sc.nextInt();
sum = sc.nextInt();
for (int i = 0; i < n; i++)
a[i] = sc.nextInt();
dfs(0, 0, 0);
System.out.println(ans);
}
}
2.最优性剪枝
如果当前条件所创造出的答案必定比之前的答案大，那么剩下的搜索就毫无必要，甚至可以剪掉。我们利用某个函数估计出此时条件下答案的‘下界’，将它与已经推出的答案相比，如果不比当前答案小，就可以剪掉。尤其是求解迷宫最优解时。
题目：有一个n x m大小的迷宫，字符 'S'表示起点，字符'T'表示终点, '*'表示墙壁，字符'.'表示平地。求S到T的最少步数。
代码如下：
import java.util.Scanner;
public class L9 {
static int n, m, ans = Integer.MAX_VALUE;
static char[][] map = new char[110][110];
static boolean[][] vis = new boolean[110][110];
static int[][] dir = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };
static boolean in(int x, int y) {
return 0 <= x && x < n && 0 <= y && y < m;
}
static void dfs(int x, int y, int step) {
if (step >= ans) {// 如果步数已经超过当前最优解，那么直接剪掉
return;
}
if (map[x][y] == 'T') {
ans = step;
return;
}
vis[x][y] = true;
for (int i = 0; i < 4; i++) {
int tx = x + dir[i][0];
int ty = y + dir[i][1];
if (in(tx, ty) && !vis[tx][ty] && map[tx][ty] != '*') {
dfs(tx, ty, step + 1);
}
}
vis[x][y] = false;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
for (int i = 0; i < n; i++) {
map[i] = sc.next().toCharArray();
}
int x=0,y=0;
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
if(map[i][j]=='S') {
x=i;
y=j;
}
}
}
dfs(x,y,0);
System.out.println(ans);
}
}
3.重复性剪枝
对于某一些特定的搜索方式，一个方案会被搜索很多次，这样是没有必要的。
对于第一题，通过每次选取一个数，下次再选另外的数的思路，可以通过规定选取数的次序使用重复性剪枝。
代码如下：
import java.util.Scanner;
public class L2 {
static int n, k, sum, ans;
static int[] a = new int[40];
static boolean[] xuan = new boolean[40];
static void dfs(int s, int cnt, int pos) {
if (s > sum || cnt > k)
return;
if (s == sum && cnt == k) {
ans++;
return;
}
for (int i = pos; i < n; i++) {
if (!xuan[i]) {
xuan[i] = true;
dfs(s + a[i], cnt + 1, i + 1);
xuan[i] = false;
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
k = sc.nextInt();
sum = sc.nextInt();
for (int i = 0; i < n; i++)
a[i] = sc.nextInt();
dfs(0, 0, 0);
System.out.println(ans);
}
}
4.奇偶性剪枝
先看题目：有一个n x m 的迷宫，其中字符 ‘S’代表起点，字符‘D’代表终点，字符‘X’代表墙壁，字符‘.’代表平地，从S到D，每次行动消耗1时间，走过的路都会坍塌，因此不能原地不动或回头，现在一直大门会在T时间打开，判断在0时间能否逃离迷宫。
我们只需要dfs每条路径，只搜到T时间就可以了，但是还可以继续剪枝。
代码如下：
import java.util.Scanner;
public class L10 {
static int n, m, T;
static char[][] map = new char[10][10];
static boolean[][] vis = new boolean[10][10];
static int[] dx = { 0, 0, -1, 1 };
static int[] dy = { 1, -1, 0, 0 };
static boolean ok;
static void dfs(int x, int y, int t) {
if (ok)
return;
if (t == T) {
if (map[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 || map[tx][ty] == 'X' || vis[tx][ty])
continue;
dfs(tx, ty, t + 1);
}
vis[x][y] = false;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
T = sc.nextInt();
for (int i = 0; i < n; i++) {
map[i] = sc.next().toCharArray();
}
int sx = 0, sy = 0, ex = 0, ey = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (map[i][j] == 'S') {
sx = i;
sy = j;
}
if (map[i][j] == 'D') {
ex = i;
ey = j;
}
}
if ((sx + sy + ex + ey + T) % 2 != 1) {// 奇偶性剪枝
System.out.println("NO");
} else {
ok = false;
dfs(sx, sy, 0);
if (ok) {
System.out.println("Yes");
} else {
System.out.println("No");
}
}
}
}
}