【算法很美】深入递归 （下）深度优先搜索DFS问题
深搜、回溯、剪枝
深度优先搜索DFS
- 2.1 无死角搜索I
-
- 数独游戏
- 部分和
- 水洼数目
- 2.2 回溯和剪枝
-
- n皇后问题
- 素数环
- 困难的串
- 小结
- 一些使用
2.1 无死角搜索I
数独游戏
你一定听说过“数独”游戏。
如下图所示，玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个同色九宫内的数字均含1-9，不重复。
数独的答案都是唯一的，所以，多个解也称为无解。
本图的数字据说是芬兰数学家花了3个月的时间设计出来的较难的题目。但对会使用计算机编程的你来说，恐怕易如反掌了。
本题的要求就是输入数独题目，程序输出数独的唯一解。我们保证所有已知数据的格式都是合法的，并且题目有唯一的解。
格式要求，输入9行，每行9个数字，0代表未知，其它数字为已知。
输出9行，每行9个数字表示数独的解。输入： 005300000 800000020 070010500 400005300 010070006 003200080 060500009 004000030 000009700 程序应该输出： 145327698 839654127 672918543 496185372 218473956 753296481 367542819 984761235 521839764 再例如，输入： 800000000 003600000 070090200 050007000 000045700 000100030 001000068 008500010 090000400 程序应该输出： 812753649 943682175 675491283 154237896 369845721 287169534 521974368 438526917 796318452
import java.util.Scanner;
public class dfs1_数独 {
public static void main(String[] args) {
// 输入
Scanner sc = new Scanner(System.in);
char[][] table = new char[9][];
for (int i = 0; i < 9; i++) {
table[i] = sc.nextLine().toCharArray();
}
dfs(table, 0, 0);
}
public static void dfs(char[][] table, int x, int y) {
// x,y为当前所在位置
// 到达边界
if (x == 9) {
print(table);
System.exit(0);
}
// 若当前位置没有填数,则挑选符合条件的数进行填入
if (table[x][y] == '0') {
for (int i = 1; i <= 9; i++) { // 1~9数字中挑
if (check(table, x, y, i)) { // 判断i是否符合要求
table[x][y] = (char) (i + '0');
dfs(table, x + (y + 1) / 9, (y + 1) % 9);
}
}
table[x][y] = '0'; // 回溯
} else { // 若当前位置已有数字,跳过进入下一个数字
dfs(table, x + (y + 1) / 9, (y + 1) % 9); // 处理下一个状态
}
}
private static void print(char[][] table) {
for (int i = 0; i < 9; i++) {
System.out.println(new String(table[i]));
}
}
private static boolean check(char[][] table, int x, int y, int k) {
// 所在行、列是否有数字i
for (int j = 0; j < 9; j++) {
if (table[x][j] == (char) (k + '0'))
return false;
if (table[j][y] == (char) (k + '0'))
return false;
}
// 检查小九宫格
for (int l = (x / 3) * 3; l < (x / 3 + 1) * 3; l++) {
for (int m = (y / 3) * 3; m < (y / 3 + 1) * 3; m++) {
if (table[l][m] == (char) (k + '0'))
return false;
}
}
return true;
}
}
注意一行一行递归是怎么实现的，以及点的小九宫格是怎么实现的
部分和
给定整数序列a1,a2,…,an,判断是否可以从中选出若干数,使它们的和恰好为k.
1≤n≤20 -10^8≤ai≤10^8 -10^8≤k≤10^8样例:
输入: n=4 a={1,2,4,7} k=13 输出: Yes (13 = 2 + 4 + 7)
与非空子集的做法类似
import java.util.ArrayList;
import java.util.Scanner;
public class dfs2_部分和 {
private static int kk;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = sc.nextInt();
}
int k = sc.nextInt();
kk = k;
dfs(a, k, 0, new ArrayList<Integer>());
}
private static void dfs(int[] a, int k, int cur, ArrayList<Integer> ints) {
// 出口
if (k == 0) {
System.out.print("Yes (" + kk + " = ");
int size = ints.size();
for (int i = 0; i < size; i++) {
System.out.print(ints.get(i) + (i == size - 1 ? "" : " + "));
}
System.out.print(")");
System.exit(0);
}
if (k < 0 || cur == a.length)
return;
dfs(a, k, cur + 1, ints); // 不选当前cur这个数
// 选cur这个数
ints.add(a[cur]);
int idx = ints.size() - 1; // 当前cur加入ints所处的位置
dfs(a, k - a[cur], cur + 1, ints);
ints.remove(idx); // 回溯
}
}
水洼数目
有一个大小为 N*M 的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出园子里总共有多少水洼？（八连通指的是下图中相对 W 的*的部分）
*** *W* ***限制条件： N, M ≤ 100
样例:
输入
N=10, M=12园子如下图（'W’表示积水， '.'表示没有积水）
W........WW. .WWW.....WWW ....WW...WW. .........WW. .........W.. ..W......W.. .W.W.....WW. W.W.W.....W. .W.W......W. ..W.......W.输出
3
拓展下一个状态点时，将该状态点由 ‘ w ’ 转为 ’ . '，防止搜索时往回走
import java.util.Scanner;
public class dfs3_水洼数目 {
private static int n;
private static int m;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
char[][] a = new char[n][];
for (int i = 0; i < n; i++) {
a[i] = sc.next().toCharArray();
}
int cnt = 0; // 计数
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == 'W') {
dfs(a, i, j);
cnt++; // 该次搜索成功,连通数加1
}
}
}
System.out.println(cnt);
}
private static void dfs(char[][] a, int i, int j) {
// 将‘w’转为‘.’,避免往回搜索造成死循环
a[i][j] = '.';
// 走下一步
for (int k = -1; k < 2; k++) {
for (int l = -1; l < 2; l++) {
if (k == 0 && l == 0) // 当前位置,不用搜索
continue;
// i为行,j为列,下一步搜索行要>0、<=n-1,列要>0、<=m-1
if (i + k >= 0 && i + k <= n - 1 && j + l >= 0 && j + l <= m - 1) {
if (a[i + k][j + l] == 'W')
dfs(a, i + k, j + l);
}
}
}
}
}
2.2 回溯和剪枝
n皇后问题
请设计一种算法，解决著名的n皇后问题。这里的n皇后问题指在一个n*n的棋盘上放置n个棋子，使得每行每列和每条对角线上都只有一个棋子，求其摆放的方法数。
给定一个int n，请返回方法数，保证n小于等于15
public class dfs4_n皇后问题 {
private static int n;
private static int[] rec;
private static int cnt;
public static void main(String[] args) {
n = 4;
rec = new int[8];
dfs(0);
System.out.println(cnt);
}
// 一行一行的试探
private static void dfs(int row) {
// 出口
if (row == n) {
cnt++;
return;
}
// 依次尝试在某列上放一个皇后
for (int col = 0; col < n; col++) {
boolean flag = true;
// 检验这个皇后是否和之前已经放置的皇后有冲突,check
for (int i = 0; i < row; i++) {
if (rec[i] == col || i + rec[i] == row + col || rec[i] - i == col - row) {
flag = false;
break;
}
}
/* =======这里可以认为是剪枝======= */
// 这一行的这一列可以放
if (flag) {
rec[row] = col;
dfs(row + 1);
// rec[row]=0;
//恢复原状，这种解法这里是否恢复状态都行，因为check都是check之前的行
}
}
}
}
注意：
x - y 相同，彼此在彼此正对角线上；
x + y 相同，彼此在彼此负对角线上；
素数环
题源 《算法竞赛入门经典》
输入正整数n，对1-n进行排列，使得相邻两个数之和均为素数，
输出时从整数1开始，逆时针排列。同一个环应恰好输出一次。
n<=16
输入：6
输出：
1 4 3 2 5 6
1 6 5 2 3 4
import java.util.Scanner;
public class dfs5_素数环 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] rec = new int[n];
rec[0] = 1; // 首位为1
dfs(n, rec, 1);
}
private static void dfs(int n, int[] rec, int cur) {
if (cur == n && isPrime(rec[0] + rec[n - 1])) {
// 输出
for (int i = 0; i < rec.length; i++) {
System.out.print(rec[i] + (i == rec.length - 1 ? "" : " "));
}
System.out.println();
}
for (int i = 2; i <= n; i++) {
if (check(rec, i, cur)) {
rec[cur] = i;
dfs(n, rec, cur + 1);
rec[cur] = 0; // 回溯
}
}
}
private static boolean check(int[] rec, int i, int cur) {
for (int e : rec) {
if (e == i || !isPrime(rec[cur - 1] + i)) {
return false;
}
}
return true;
}
private static boolean isPrime(int k) {
for (int i = 2; i * i <= k; i++) {
if (k % i == 0)
return false;
}
return true;
}
}
困难的串
题源 《算法竞赛入门经典》
问题描述:
如果一个字符串包含两个相邻的重复子串，则称它为容易的串，其他串称为困难的串，如:
BB，ABCDACABCAB, ABCDABCD 都是容易的，
A, AB, ABA, D, DC, ABDAB, CBABCBA 都是困难的。
输入正整数n,L，输出由前L个字符(大写英文字母)组成的，字典序第n小的困难的串。
例如，当L=3时，前7个困难的串分别为:
A, AB, ABA, ABAC, ABACA, ABACAB, ABACABA
n指定为4的话,输出ABAC
public class dfs6_困难的串 {
static int count;
public static void main(String[] args) {
int n = 10; // 第n小的字符串
int l = 4; // 字母范围为前l个字符
dfs(l, n, "");
}
private static void dfs(int l, int n, String prefix) {
// 给前缀串prefix后追加一个字符
for (char i = 'A'; i < 'A' + l; i++) {
if (isHard(prefix, i)) { // 是困难串就组合起来输出
String x = prefix + i;
System.out.println(x);
count++;
if (count == n)
System.exit(0);
dfs(l, n, x);
}
}
}
// 判断prefix+i是否一个困难的串
private static boolean isHard(String prefix, char i) {
int count = 0;
for (int j = prefix.length() - 1; j >= 0; j -= 2) {
final String s1 = prefix.substring(j, j + count + 1);
final String s2 = prefix.substring(j + count + 1) + i;
if (s1.equals(s2))
return false;
count++;
}
return true;
}
}
小结
一些使用
char型 + “ ” 可以转为字符串String型
new String(arr) 将arr数组转为字符串
int i = 1; char c = (char) i; System.out.println(c); c = (char) ('0' + 1);头一个输出会输出一个乱字符：
后一个输出才会输出字符1