回溯算法总结
解题的步骤是：先画图，再编码。去思考可以剪枝的条件， 为什么有的时候用 used 数组，有的时候设置搜索起点 begin 变量，理解状态变量设计的想法。
本序列参考资料
1.回溯算法入门级详解 + 练习
2.回溯法总结
3.
回溯算法主要有排列、组合、子集相关问题，Flood Fill，字符串中的回溯问题，游戏问题四大题型。
题型一：排列、组合、子集相关问题
题目一：全排列（46. 全排列）
代码如下：
class Solution {
public List<List<Integer>> permute(int[] nums) {
int len = nums.length;
List<List<Integer>> res = new ArrayList<>();
if (null == nums || 0 == len) {
return res;
}
// 栈的实现，java语言要求
Deque<Integer> path = new ArrayDeque<>();
// 标记数字是否有使用过，默认为false没有使用过
boolean[] used = new boolean[len];
dfs(nums, len, 0, path, used, res);
return res;
}
// 题目要求所有的搜索结果，所有找到一个结果返回上一层后还可以继续找下一个结果。如果题目要求只要一个结果，dfs可以返回boolean
// 在一些地方可以及时退出
private void dfs(int[] nums, int len, int depth, Deque<Integer> path, boolean[] used, List<List<Integer>> res) {
// 递归结束的条件，depth从0开始，只要等于nums长度即可结束递归
if (depth == len) {
// path保存的是一个引用，dfs结束后，path内没有任何元素，所以每次用res保存结果时必须新建一个path的副本（即new // ArrayList(path)）
res.add(new ArrayList(path));
return;
}
for (int i = 0; i < len; i ++) {
if (used[i] == false) {
used[i] = true;
// 往栈中添加一个元素
path.addLast(nums[i]);
dfs(nums, len, depth + 1, path, used, res);
// 删除栈中一个元素
path.removeLast();
used[i] = false;
}
}
}
}
题目二：全排列（47. 全排列 II）
题解：给出的序列中数字有重复的，所以要考虑剪枝。
class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
int len = nums.length;
List<List<Integer>> res = new ArrayList<>();
if (null == nums || 0 == len) {
return res;
}
// 剪枝的前提，排序后可以剪枝
Arrays.sort(nums);
Deque<Integer> path = new ArrayDeque<>();
boolean[] used = new boolean[len];
dfs(nums, len, 0, path, used, res);
return res;
}
private void dfs(int[] nums, int len, int depth, Deque<Integer> path, boolean[] used, List<List<Integer>> res) {
if (depth == len) {
res.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < len; i ++) {
if (used[i]) {
continue;
}
// 剪枝
if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
continue;
}
used[i] = true;
path.addLast(nums[i]);
dfs(nums, len, depth + 1, path, used, res);
used[i] = false;
path.removeLast();
}
}
}
题目三：组合总和（39. 组合总和）
题解：1.由于给出的序列，可以无限制重复被选取。所以不能使用boolean used[]数组来标记给出的序列是否使用过。2.题目要求解集不能包含重复的组合。所以用begin指针标记使用的数字从哪里开始。即不能使用当前序列数字之前的数字。
代码如下：
class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
int len = candidates.length;
List<List<Integer>> res = new ArrayList<>();
if (0 == len) {
return res;
}
// 为了剪枝让给定的序列排序
Arrays.sort(candidates);
Deque<Integer> path = new ArrayDeque<>();
dfs(candidates, 0, target, path, res);
return res;
}
// 由于给定的序列数字可以无限制重复被选取，所以不用boolean used[]数组。
private void dfs(int[] candidates, int begin, int target, Deque<Integer> path, List<List<Integer>> res) {
if (0 == target) {
res.add(new ArrayList<>(path));
return;
}
// 解集不能包含重复的组合，所以选取下一个数字是必须从当前数字往后尝试
for (int i = begin; i < candidates.length; i ++) {
// 剪枝，由于已经排好序（从小到大），所以只要target < candidates[i]即可跳出循环
if (target - candidates[i] < 0) {
break;
}
path.addLast(candidates[i]);
// 由于给定的序列数字可以无限制重复被选取，所以下一个数字还可以选取当前这个数字
dfs(candidates, i, target - candidates[i], path, res);
path.removeLast();
}
}
}
题目四：组合总和（40. 组合总和 II）
代码如下：
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
int len = candidates.length;
List<List<Integer>> res = new ArrayList<>();
if (null == candidates || 0 == len || target < 0) {
return res;
}
Arrays.sort(candidates);
Deque<Integer> path = new ArrayDeque<>();
dfs(candidates, 0, target, path, res);
return res;
}
private void dfs(int[] candidates, int begin, int target, Deque<Integer> path, List<List<Integer>> res) {
if (0 == target) {
res.add(new ArrayList<>(path));
return;
}
for (int i = begin; i < candidates.length; i ++) {
// 大剪枝
if (target - candidates[i] < 0) {
break;
}
// 小剪枝
if (i > begin && candidates[i] == candidates[i - 1]) {
continue;
}
path.addLast(candidates[i]);
dfs(candidates, i + 1, target - candidates[i], path, res);
path.removeLast();
}
}
}
总结：
1.题目要求解集不能重复，应当使用begin变量标记每一层所要遍历的序列。
2.题目要求解集可以重复，每一层遍历序列可以全部遍历。
3.题目要求给出的序列数字可以无限制重复被选取。进入下一层时深度（depth）依然是从当前数字开始搜索。即dfs(candidates, i, target - candidates[i], path, res);
4.题目要求给出的序列每个数字在每个组合中只能使用一次。进入下一层时深度（depth）应当是下一个数字开始。即dfs(candidates, len, i + 1, target - candidates[i], path, res);
5.剪枝应当要对给出的序列进行排序。
题目五：组合（77. 组合）
代码如下：
class Solution {
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
Deque<Integer> path = new ArrayDeque<>();
dfs(n, 0, k, 1, path, res);
return res;
}
private void dfs(int n, int depth, int k, int begin, Deque<Integer> path, List<List<Integer>> res) {
if (depth == k) {
res.add(new ArrayList<>(path));
return;
}
for (int i = begin; i <= n; i ++) {
path.addLast(i);
dfs(n, depth + 1, k, i + 1, path, res);
path.removeLast();
}
}
}
题目六：子集（78. 子集）
代码如下：
class Solution {
public List<List<Integer>> subsets(int[] nums) {
int len = nums.length;
List<List<Integer>> res = new ArrayList<>();
res.add(new ArrayList<>());
if (null == nums || 0 == len) {
return res;
}
Deque<Integer> path = new ArrayDeque<>();
for (int i = 1; i <= len; i ++) {
dfs(nums, 0, i, 0, path, res);
}
return res;
}
private void dfs(int[] nums, int depth, int k, int begin, Deque<Integer> path, List<List<Integer>> res) {
if (depth == k) {
res.add(new ArrayList<>(path));
return;
}
for (int i = begin; i < nums.length; i ++) {
path.addLast(nums[i]);
dfs(nums, depth + 1, k, i + 1, path, res);
path.removeLast();
}
}
}
题目七：子集（90. 子集 II）
代码如下：
public List<List<Integer>> subsetsWithDup(int[] nums) {
int len = nums.length;
List<List<Integer>> res = new ArrayList<>();
if (null == nums || 0 == len) {
return res;
}
// 剪枝的前提：排序
Arrays.sort(nums);
Deque<Integer> path = new ArrayDeque<>();
for (int i = 0; i <= nums.length; i ++) {
dfs(nums, 0, 0, i, path, res);
}
return res;
}
private void dfs(int[] nums, int depth, int begin, int k, Deque<Integer> path, List<List<Integer>> res) {
if (depth == k) {
res.add(new ArrayList<>(path));
return;
}
for (int i = begin; i < nums.length; i ++) {
if (i > begin && nums[i] == nums[i - 1]) {
continue;
}
path.addLast(nums[i]);
dfs(nums, depth + 1, i + 1, k, path, res);
path.removeLast();
}
}
题目八：第k个排列（60. 第k个排列）
题解：1.题目没有要求题目要求解集可以重复，每一层遍历序列可以全部遍历。
代码如下：
class Solution {
private int sum = 0;
public String getPermutation(int n, int k) {
int[] nums = new int[n];
boolean[] used = new boolean[n];
Deque<Integer> path = new ArrayDeque<>();
for (int i = 0; i < n; i ++) {
nums[i] = i + 1;
}
dfs(nums, 0, used, path, k);
List<Integer> list = new ArrayList<>(path);
StringBuilder sb = new StringBuilder();
for (int i : list) {
sb.append(i + "");
}
return sb.toString();
}
// 解法一：
// private void dfs(int[] nums, int depth, boolean[] used, Deque path, int k) {
// if (depth == nums.length) {
// sum ++;
// return;
// }
// for (int i = 0; i < nums.length; i ++) {
// if (used[i]) {
// continue;
// }
// used[i] = true;
// path.addLast(nums[i]);
// dfs(nums, depth + 1, used, path, k);
// if (sum == k) {
// return;
// }
// used[i] = false;
// path.removeLast();
// }
// }
// 解法二：
private boolean dfs(int[] nums, int depth, boolean[] used, Deque<Integer> path, int k) {
if (depth == nums.length) {
sum ++;
return sum == k;
}
for (int i = 0; i < nums.length; i ++) {
if (used[i]) {
continue;
}
used[i] = true;
path.addLast(nums[i]);
if (dfs(nums, depth + 1, used, path, k)) {
return true;
}
used[i] = false;
path.removeLast();
}
return false;
}
}
题型二：Flood Fill
Flood 是「洪水」的意思，Flood Fill 直译是「泛洪填充」的意思，体现了洪水能够从一点开始，迅速填满当前位置附近的地势低的区域。
这一类题目的dfs方法模板：
1.递归出口条件判断
2.标记
3.走不通的选择
题目一：图像渲染(733. 图像渲染)
代码如下：
class Solution {
public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
// 注意：假如一开始的值和newColor一样，直接返回结果，不然会出现死循环
if (image[sr][sc] == newColor) {
return image;
}
int value = image[sr][sc];
boolean[][] used = new boolean[image.length][image[0].length];
dfs(image, sr, sc, newColor, value, used);
return image;
}
private void dfs(int[][] image, int i, int j, int newColor, int value, boolean[][] used) {
// 递归出口条件判断
if (i < 0 || i >= image.length || j < 0 || j >= image[0].length || image[i][j] != value || used[i][j]) {
return;
}
// 标记
used[i][j] = true;
image[i][j] = newColor;
// 走不通的方向路径
dfs(image, i - 1, j, newColor, value, used);
dfs(image, i, j + 1, newColor, value, used);
dfs(image, i + 1, j, newColor, value, used);
dfs(image, i, j - 1,newColor, value, used);
}
}
题目二：岛屿数量（200. 岛屿数量）
代码如下：
class Solution {
public int numIslands(char[][] grid) {
if (null == grid || 0 == grid.length) {
return 0;
}
int sum = 0;
for (int i = 0; i < grid.length; i ++) {
for (int j = 0; j < grid[0].length; j ++) {
if (grid[i][j] == '1') {
sum ++;
dfs(grid, i, j);
}
}
}
return sum;
}
private void dfs(char[][] grid, int i, int j) {
if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0') {
return;
}
grid[i][j] = '0';
dfs(grid, i - 1, j);
dfs(grid, i, j + 1);
dfs(grid, i + 1, j);
dfs(grid, i, j - 1);
}
}
题目三： 被围绕的区域(130. 被围绕的区域)
题解：首先先从边界上开始查找是否有0的位置，将边界上0位置上所关联到的0都设置为Y，其次遍历这个区域，全部将0设置为x，最后将Y设置为0.
代码如下：
class Solution {
public void solve(char[][] board) {
if (null == board || 0 == board.length) {
return;
}
for (int j = 0; j < board[0].length; j ++) {
dfs(board, 0, j);
dfs(board, board.length - 1, j);
}
for (int i = 1; i < board.length - 1; i ++) {
dfs(board, i, 0);
dfs(board, i, board[0].length - 1);
}
for (int i = 0; i < board.length; i ++) {
for (int j = 0; j < board[0].length; j ++) {
if (board[i][j] == 'O') {
board[i][j] = 'X';
}
}
}
for (int i = 0; i < board.length; i ++) {
for (int j = 0; j < board[0].length; j ++) {
if (board[i][j] == 'Y') {
board[i][j] = 'O';
}
}
}
}
private void dfs(char[][] board, int i, int j) {
if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] == 'X' || board[i][j] == 'Y') {
return;
}
board[i][j] = 'Y';
dfs(board, i - 1, j);
dfs(board, i, j + 1);
dfs(board, i + 1, j);
dfs(board, i, j - 1);
}
}
题目四：单词搜索（79. 单词搜索）
代码如下：
class Solution {
public boolean exist(char[][] board, String word) {
if (null == board) {
return false;
}
if (null == word || 0 == word.length()) {
return true;
}
int[][] state = new int[board.length][board[0].length];
for (int i = 0; i < board.length; i ++) {
for (int j = 0; j < board[0].length; j ++) {
if (dfs(i, j, 0, board, word, state)) {
return true;
}
}
}
return false;
}
private boolean dfs(int i, int j, int index, char[][] board, String word, int[][] state) {
if (index == word.length()) {
return true;
}
if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || state[i][j] == 1) {
return false;
}
state[i][j] = 1;
if (board[i][j] == word.charAt(index)) {
boolean res = dfs(i - 1, j, index + 1, board, word, state) ||
dfs(i + 1, j, index + 1, board, word, state) ||
dfs(i, j - 1, index + 1, board, word, state) ||
dfs(i, j + 1, index + 1, board, word, state);
state[i][j] = 0;
return res;
}
state[i][j] = 0;
return false;
}
}
题型三：字符串中的回溯问题
字符串的问题的特殊之处在于，字符串的拼接生成新对象，因此在这一类问题上没有显示「回溯」的过程，但是如果使用 StringBuilder 拼接字符串就另当别论。
题目一：电话号码的字母组合（17. 电话号码的字母组合）
代码如下：
class Solution {
public List<String> letterCombinations(String digits) {
if (null == digits || 0 == digits.length()) {
return new ArrayList<>();
}
String[][] cs = {
{
}, {
}, {
"a","b","c"},{
"d","e","f"},{
"g","h","i"},{
"j","k","l"},
{
"m","n","o"},{
"p","q","r","s"},{
"t","u","v"},{
"w","x","y","z"}};
List<String> res = new ArrayList<>();
String str = new String();
dfs(0,cs, digits,str,res);
return res;
}
private void dfs(int step, String[][] cs, String digits, String str, List<String> res) {
// step = 0
if (step == digits.length() - 1) {
if (digits.charAt(step) == '7' || digits.charAt(step) == '9') {
for (int i = 0; i < 4; i ++) {
String s1 = str + cs[digits.charAt(step) - '0'][i];
res.add(s1);
}
} else {
for (int i = 0; i < 3; i ++) {
String s1 = str + cs[digits.charAt(step) - '0'][i];
res.add(s1);
}
}
return;
}
if (digits.charAt(step) == '7' || digits.charAt(step) == '9') {
for (int i = 0; i < 4; i ++) {
str += cs[digits.charAt(step) - '0'][i];
dfs(step + 1, cs,digits, str,res);
str = str.substring(0,str.length() - 1);
}
} else {
for (int i = 0; i < 3; i ++) {
str += cs[digits.charAt(step) - '0'][i];
dfs(step + 1, cs,digits, str,res);
str = str.substring(0,str.length() - 1);
}
}
return;
}
}
题目二:字母大小写全排列（784. 字母大小写全排列）
代码如下：
class Solution {
public List<String> letterCasePermutation(String S) {
int len = S.length();
List<String> res = new ArrayList<>();
if (0 == len) {
return res;
}
char[] charArray = new char[len];
dfs(S, len, 0, charArray, res);
return res;
}
// start 从0开始
private void dfs(String S, int len, int start, char[] charArray, List<String> res) {
if (start == len) {
res.add(new String(charArray));
return;
}
charArray[start] = S.charAt(start);
dfs(S, len, start + 1, charArray, res);
if (Character.isLetter(S.charAt(start))) {
// 大小写转化
charArray[start] = (char)(S.charAt(start) ^ (1 << 5));
dfs(S, len, start + 1, charArray, res);
}
}
}
题目三:括号生成（22. 括号生成）
代码如下：
class Solution {
public List<String> generateParenthesis(int n) {
List<String> res = new ArrayList<>();
dfs("", n, n, res);
return res;
}
private void dfs(String curStr, int left, int right, List<String> res) {
if (0 == left && 0 == right) {
res.add(curStr);
return;
}
if (left > right) {
return;
}
if (right > 0) {
dfs(curStr + ")", left, right - 1, res);
}
if (left > 0) {
dfs(curStr + "(", left - 1, right, res);
}
}
}
题型四：游戏问题
题目一:N 皇后(51. N 皇后)
题解：参考资料
代码如下：
class Solution {
private int n;
private boolean[] col;
private boolean[] master;
private boolean[] slave;
private List<List<String>> res;
public List<List<String>> solveNQueens(int n) {
this.n = n;
col = new boolean[n];
master = new boolean[2 * n - 1];
slave = new boolean[2 * n - 1];
res = new ArrayList<>();
Deque<Integer> stack = new ArrayDeque<>();
dfs(0, stack);
return res;
}
private void dfs(int row, Deque<Integer> stack) {
if (row == n) {
List<String> board = covert2Board(stack, n);
res.add(board);
return;
}
for (int i = 0; i < n; i ++) {
if (!col[i] && !master[row + i] && !slave[row - i + n - 1]) {
stack.addLast(i);
col[i] = true;
master[row + i] = true;
slave[row - i + n - 1] = true;
dfs(row + 1, stack);
col[i] = false;
master[row + i] = false;
slave[row - i + n - 1] = false;
stack.removeLast();
}
}
}
// 保存一个结果的stack，皇后数量：n
private List<String> covert2Board(Deque<Integer> stack, int n) {
List<String> board = new ArrayList<>();
for (Integer num : stack) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i ++) {
sb.append(".");
}
sb.replace(num, num + 1, "Q");
board.add(sb.toString());
}
return board;
}
}
题目二:解数独(37. 解数独)
题解:参考资料
代码如下：
// 方块，行，列都是从0开始
class Solution {
private boolean[][] rows;
private boolean[][] cols;
private boolean[][] blocks;
public void solveSudoku(char[][] board) {
rows = new boolean[9][10];
cols = new boolean[9][10];
blocks = new boolean[9][10];
for (int i = 0; i < board.length; i ++) {
for (int j = 0; j < board[0].length; j ++) {
if (board[i][j] != '.') {
rows[i][board[i][j] - '0'] = true;
cols[j][board[i][j] - '0'] = true;
blocks[blockIndex(i, j)][board[i][j] - '0'] = true;
}
}
}
dfs(0, board);
}
// 题目要求只要找到一种解法即可，找到后就返回，而且还要保留这一种结果。
// 找到后通过返回true即可向上退出。如果题目要求返回所有的结果即dfs方法返回void
private boolean dfs(int depth, char[][] board) {
if (depth == 81) {
return true;
}
int row = rowIndex(depth);
int col = colIndex(depth);
if (board[row][col] != '.') {
return dfs(depth + 1, board);
} else {
for (int i = 1; i < 10; i ++) {
if (rows[row][i] || cols[col][i] || blocks[blockIndex(row, col)][i]) {
continue;
}
board[row][col] = (char)('0' + i);
rows[row][i] = true;
cols[col][i] = true;
blocks[blockIndex(row, col)][i] = true;
if (dfs(depth + 1, board)) {
return true;
}
board[row][col] = '.';
rows[row][i] = false;
cols[col][i] = false;
blocks[blockIndex(row, col)][i] = false;
}
}
return false;
}
private int blockIndex(int i, int j) {
return i / 3 * 3 + j / 3;
}
private int rowIndex(int depth) {
return depth / 9;
}
private int colIndex(int depth) {
return depth % 9;
}
}