一、入门例子
package com.itheima.algorithms.backtracking;
import java.util.LinkedList;
/**
* 回溯
* 程序在运行过程中分成了多个阶段
* 通过某些手段，将数据恢复到之前某一阶段，这就称之为回溯
* 手段包括
* 方法栈
* 自定义栈
*/
public class Backtracking {
public static void main(String[] args) {
rec(1, new LinkedList<>());
}
private static void rec(int n, LinkedList<String> list) {
if(n == 3) {
return;
}
System.out.println("before: " + list);
list.push("a");
rec(n + 1, list);
list.pop();
System.out.println("after: " + list);
}
}
before: []
before: [a]
after: [a]
after: []二、全排列
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1：
输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2：
输入：nums = [0,1] 输出：[[0,1],[1,0]]
示例 3：
输入：nums = [1] 输出：[[1]]
提示：
1 <= nums.length <= 6-10 <= nums[i] <= 10nums中的所有整数 互不相同
解法一：回溯
class Solution {
public List<List<Integer>> permute(int[] nums) {
boolean[] visited = new boolean[nums.length];
LinkedList<Integer> stack = new LinkedList<>();
List<List<Integer>> result = new ArrayList<>();
recursion(nums, visited, stack, result);
return result;
}
private void recursion(int[] nums, boolean[] visited, LinkedList<Integer> stack, List<List<Integer>> result) {
if (stack.size() == nums.length) {
result.add(new ArrayList<>(stack));
return;
}
for (int i = 0; i < nums.length; i++) {
if (visited[i]) {
continue;
}
stack.push(nums[i]);
visited[i] = true;
recursion(nums, visited, stack, result);
visited[i] = false;
stack.pop();
}
}
}三、全排列Ⅱ
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
示例 1：
输入：nums = [1,1,2] 输出： [[1,1,2], [1,2,1], [2,1,1]]
示例 2：
输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示：
1 <= nums.length <= 8-10 <= nums[i] <= 10
解法一：回溯 + 剪枝
- 排好序，这样重复的数字会相邻
- 定好规则：必须1固定之后才能固定1'，即1的visited = true时才能继续处理1'
- 在遍历时，遇到了nums[i] == nums[i - 1]（即1和1'这种情况），进一步检查i-1位置的数字有没有visited，没有则不处理（剪枝）。
class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
// 相同元素放在相近的位置
Arrays.sort(nums);
List<List<Integer>> result = new ArrayList<>();
boolean[] visited = new boolean[nums.length];
LinkedList<Integer> stack = new LinkedList<>();
dfs(nums, visited, stack, result);
return result;
}
private void dfs(int[] nums, boolean[] visited, LinkedList<Integer> stack, List<List<Integer>> result) {
if (stack.size() == nums.length) {
result.add(new ArrayList<>(stack));
return;
}
for (int i = 0; i < nums.length; i++) {
// 先固定前一个相同元素，再固定后一个
if (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
// 找出相邻重复数字
continue;
}
if (!visited[i]) {
stack.push(nums[i]);
visited[i] = true;
dfs(nums, visited, stack, result);
visited[i] = false;
stack.pop();
}
}
}
}四、组合
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
示例 1：
输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]
示例 2：
输入：n = 1, k = 1 输出：[[1]]
提示：
1 <= n <= 201 <= k <= n
解法一：递归 + 剪枝。执行耗时20ms
class Solution {
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
dfs(result, path, 1, n, k);
return result;
}
private void dfs(List<List<Integer>> result, LinkedList<Integer> path, int start, int n, int k) {
// 如果k为0，说明已选择了k个数，加入结果
if (k == 0) {
result.add(new ArrayList<>(path));
return;
}
// 从start开始选择，直到n
for (int i = start; i <= n; i++) {
// 剪枝: 如果剩余元素少于k，则不需要继续搜索
if (k > n - i + 1) {
break; // 这里将 continue 替换为 break
}
// 添加当前元素到路径
path.add(i);
// 继续递归选择下一个元素
dfs(result, path, i + 1, n, k - 1);
// 撤销选择当前元素
path.removeLast();
}
}
}或用ArrayList实现stack -> 执行耗时13ms
class Solution {
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> result = new ArrayList<>();
if(k == 0 || n < k) return result;
dfs(n, k, 1, new ArrayList<>(), result);
return result;
}
static void dfs(int n, int k, int start, ArrayList<Integer> stack, List<List<Integer>> result) {
if (k == 0) {
result.add(new ArrayList<>(stack));
return;
}
for (int i = start; i <= n; i++) {
if (k-1 > n - i) {
continue;
}
stack.add(i);
dfs(n, k - 1, i + 1, stack, result);
stack.remove(stack.size()-1);
}
}
}五、组合总和
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
示例 1：
输入：candidates = [2,3,6,7], target = 7 输出：[[2,2,3],[7]] 解释： 2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。 仅有这两种组合。
示例 2：
输入: candidates = [2,3,5], target = 8 输出: [[2,2,2,2],[2,3,3],[3,5]]
示例 3：
输入: candidates = [2], target = 1 输出: []
提示：
1 <= candidates.length <= 302 <= candidates[i] <= 40candidates的所有元素 互不相同1 <= target <= 40
解法一：回溯
class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> current = new LinkedList<>();
dfs(candidates, target, 0, current, result);
return result;
}
private void dfs(int[] candidates, int target, int start, LinkedList<Integer> current, List<List<Integer>> result) {
if (target == 0) {
result.add(new ArrayList<>(current));
return;
}
for (int i = start; i < candidates.length; i++) {
int candidate = candidates[i];
if(target < candidate) { // 剪枝
continue;
}
current.push(candidates[i]);
dfs(candidates, target - candidate, i, current, result);
current.pop();
}
}
}六、组合总和Ⅱ
给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用 一次 。
注意：解集不能包含重复的组合。
示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8, 输出: [ [1,1,6], [1,2,5], [1,7], [2,6] ]
示例 2:
输入: candidates = [2,5,2,1,2], target = 5, 输出: [ [1,2,2], [5] ]
提示:
1 <= candidates.length <= 1001 <= candidates[i] <= 501 <= target <= 30
解法一：执行耗时3ms
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
List<List<Integer>> result = new ArrayList<>();
dfs(target, 0, candidates, new boolean[candidates.length], new LinkedList<>(), result);
return result;
}
static void dfs(int target, int start, int[] candidates, boolean[] visited, LinkedList<Integer> stack,
List<List<Integer>> result) {
if (target == 0) {
result.add(new ArrayList<>(stack));
return;
}
for (int i = start; i < candidates.length; i++) {
int candidate = candidates[i];
if (target < candidate) {
continue;
}
if (i > 0 && candidate == candidates[i - 1] && !visited[i - 1]) {
continue;
}
visited[i] = true;
stack.push(candidate);
dfs(target - candidate, i + 1, candidates, visited, stack, result);
stack.pop();
visited[i] = false;
}
}
}解法二：执行耗时5ms
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> stack = new LinkedList<>();
dfs(candidates, target, 0, stack, result);
return result;
}
private void dfs(int[] candidates, int target, int start, LinkedList<Integer> stack, List<List<Integer>> result) {
if (target < 0) {
return;
}
if (target == 0) {
result.add(new ArrayList<>(stack));
return;
}
for (int i = start; i < candidates.length; i++) {
if (i > start && candidates[i] == candidates[i - 1]) {
continue;
}
stack.push(candidates[i]);
dfs(candidates, target - candidates[i], i + 1, stack, result);
stack.pop();
}
}
}七、组合总和Ⅲ
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
- 只使用数字1到9
- 每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
示例 1:
输入: k = 3, n = 7 输出: [[1,2,4]] 解释: 1 + 2 + 4 = 7 没有其他符合的组合了。
示例 2:
输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]] 解释: 1 + 2 + 6 = 9 1 + 3 + 5 = 9 2 + 3 + 4 = 9 没有其他符合的组合了。
示例 3:
输入: k = 4, n = 1 输出: [] 解释: 不存在有效的组合。 在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。
提示:
2 <= k <= 91 <= n <= 60
解法一：回溯
class Solution {
public List<List<Integer>> combinationSum3(int k, int n) {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> stack = new LinkedList<>();
dfs(k, n, 1, stack, result);
return result;
}
private void dfs(int k, int n, int start, LinkedList<Integer> stack, List<List<Integer>> result) {
if (n == 0 && stack.size() == k) {
result.add(new ArrayList<>(stack));
return;
}
for (int i = start; i <= 9; i++) {
if (n < i) {
continue;
}
if (stack.size() == k) {
continue;
}
stack.push(i);
dfs(k, n - i, i + 1, stack, result);
stack.pop();
}
}
}八、N皇后
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
示例 1：
输入：n = 4 输出：[[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]] 解释：如上图所示，4 皇后问题存在两个不同的解法。
示例 2：
输入：n = 1 输出：[["Q"]]
提示：
1 <= n <= 9
解法一：执行耗时2ms
class Solution {
public List<List<String>> solveNQueens(int n) {
List<List<String>> result = new ArrayList<>();
char[][] table = new char[n][n];
for (int i = 0; i < n; i++) {
Arrays.fill(table[i], '.');
}
dfs(0, n, table, result);
return result;
}
private void dfs(int i, int n, char[][] table, List<List<String>> result) {
if (i == n) {
ArrayList<String> list = new ArrayList<>();
for (char[] chars : table) {
list.add(String.valueOf(chars));
}
result.add(list);
return;
}
for (int j = 0; j < n; j++) {
if (notValid(table, i, j)) {
continue;
}
table[i][j] = 'Q';
dfs(i + 1, n, table, result);
table[i][j] = '.';
}
}
private boolean notValid(char[][] table, int row, int col) {
int n = table.length;
for (int i = 0; i < n; i++) {
if (table[i][col] == 'Q') {
return true;
}
}
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (table[i][j] == 'Q') {
return true;
}
}
for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (table[i][j] == 'Q') {
return true;
}
}
return false;
}
}解法二：执行耗时1ms
class Solution {
public List<List<String>> solveNQueens(int n) {
List<List<String>> result = new ArrayList<>();
// 记录列冲突
boolean[] ca = new boolean[n];
// 大小2n - 1，记录左斜线冲突 -> i + j结果相同的为同一斜线
boolean[] cb = new boolean[2 * n - 1];
// 记录右斜线冲突 -> i - j结果相同的为同一斜线 -> 处理负数: n - 1 - (i - j)
boolean[] cc = new boolean[2 * n - 1];
char[][] table = new char[n][n];
for (char[] t : table) {
// 初始化
Arrays.fill(t, '.');
}
dfs(0, n, table, ca, cb, cc, result);
return result;
}
/**
*
* @param i 正在处理第几行
* @param n n个皇后
* @param table 棋盘
* @param ca 列冲突
* @param cb 左斜线冲突
* @param cc 右斜线冲突
* @param result
*/
private static void dfs(int i, int n, char[][] table, boolean[] ca, boolean[] cb, boolean[] cc, List<List<String>> result) {
if (i == n) {
// 找到解
List<String> res = new ArrayList<>();
for (char[] t : table) {
// System.out.println("------------");
// System.out.println(new String(t));
res.add(new String(t));
}
result.add(res);
return;
}
for (int j = 0; j < n; j++) {
// 有冲突，跳过
if (ca[j] || cb[i + j] || cc[n - 1 - (i - j)]) {
continue;
}
table[i][j] = 'Q';
ca[j] = cb[i + j] = cc[n - 1 - (i - j)] = true;
// 递归处理下一行
dfs(i + 1, n, table, ca, cb, cc, result);
// 回溯
table[i][j] = '.';
ca[j] = cb[i + j] = cc[n - 1 - (i - j)] = false;
}
}
}九、解数独
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
- 数字
1-9在每一行只能出现一次。 - 数字
1-9在每一列只能出现一次。 - 数字
1-9在每一个以粗实线分隔的3x3宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 '.' 表示。
示例 1：
输入：board = [["5","3",".",".","7",".",".",".","."],["6",".",".","1","9","5",".",".","."],[".","9","8",".",".",".",".","6","."],["8",".",".",".","6",".",".",".","3"],["4",".",".","8",".","3",".",".","1"],["7",".",".",".","2",".",".",".","6"],[".","6",".",".",".",".","2","8","."],[".",".",".","4","1","9",".",".","5"],[".",".",".",".","8",".",".","7","9"]] 输出：[["5","3","4","6","7","8","9","1","2"],["6","7","2","1","9","5","3","4","8"],["1","9","8","3","4","2","5","6","7"],["8","5","9","7","6","1","4","2","3"],["4","2","6","8","5","3","7","9","1"],["7","1","3","9","2","4","8","5","6"],["9","6","1","5","3","7","2","8","4"],["2","8","7","4","1","9","6","3","5"],["3","4","5","2","8","6","1","7","9"]] 解释：输入的数独如上图所示，唯一有效的解决方案如下所示：
提示：
board.length == 9board[i].length == 9board[i][j]是一位数字或者'.'- 题目数据 保证 输入数独仅有一个解
解法一：执行耗时3ms
class Solution {
record Pair(int i, int j) {
}
public void solveSudoku(char[][] board) {
int n = 9;
boolean[][] va = new boolean[n][n]; // 行冲突
boolean[][] vb = new boolean[n][n]; // 列冲突
boolean[][][] vc = new boolean[3][n][n]; // 九宫格冲突
List<Pair> blanks = new ArrayList<>();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (board[i][j] != '.') {
int x = board[i][j] - '0' - 1;
va[i][x] = true;
vb[j][x] = true;
vc[i / 3][j / 3][x] = true;
} else {
blanks.add(new Pair(i, j));
}
}
}
dfs(0, blanks, board, va, vb, vc);
}
private boolean dfs(int p, List<Pair> blanks, char[][] table, boolean[][] va, boolean[][] vb, boolean[][][] vc) {
if (p == blanks.size()) {
return true;
}
int n = table.length;
for (int d = 0; d < n; d++) {
Pair pair = blanks.get(p);
if (va[pair.i][d] || vb[pair.j][d] || vc[pair.i / 3][pair.j / 3][d]) {
continue;
}
char ch = (char) (d + '0' + 1);
table[pair.i][pair.j] = ch;
va[pair.i][d] = true;
vb[pair.j][d] = true;
vc[pair.i / 3][pair.j / 3][d] = true;
boolean dfs = dfs(p + 1, blanks, table, va, vb, vc);
if (dfs) {
return true;
}
table[pair.i][pair.j] = '.';
va[pair.i][d] = false;
vb[pair.j][d] = false;
vc[pair.i / 3][pair.j / 3][d] = false;
}
return false;
}
}解法二：执行耗时2ms
class Solution {
public static void solveSudoku(char[][] table) {
int n = 9;
// 行冲突 第一维表示第几行，第二维表示这一行的数字冲突状态
boolean[][] ca = new boolean[n][n];
// 列冲突 第一维表示第几列，第二维表示这一列1~9的冲突状态
boolean[][] cb = new boolean[n][n];
// 九宫格冲突
// 第几个九宫格 -> i/3*3 + j/3
boolean[][] cc = new boolean[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
char ch = table[i][j];
if (ch != '.') {
// 初始化冲突状态
ca[i][ch - '1'] = true;
cb[j][ch - '1'] = true;
cc[i / 3 * 3 + j / 3][ch - '1'] = true;
}
}
}
dfs(0, 0, table, ca, cb, cc);
}
private static boolean dfs(int i, int j, char[][] table, boolean[][] ca, boolean[][] cb, boolean[][] cc) {
// 1. 查找下一个空格
while (table[i][j] != '.') {
if (++j >= 9) {
// 已经到了行末，跳到下一行
j = 0;
i++;
}
if (i >= 9) {
// 找到解
return true;
}
}
// 2. 填空
for (int x = 1; x <= 9; x++) {
// 2.1 检查冲突
if (ca[i][x - 1] || cb[j][x - 1] || cc[i / 3 * 3 + j / 3][x - 1]) {
continue;
}
// 2.2 填入数字
table[i][j] = (char) (x + '0'); // 1 + '0' => '1'
// 如果在第0个的第0行第2列九宫格填入'1'
// ca[0][0] = true 第0行不能存储'1'
// cb[2][0] = true 第2列不能存储'1'
// cc[0][0] = true 第0个九宫格不能存储'1'
ca[i][x - 1] = cb[j][x - 1] = cc[i / 3 * 3 + j / 3][x - 1] = true;
if (dfs(i, j, table, ca, cb, cc)) {
return true;
}
// 回溯
table[i][j] = '.';
ca[i][x - 1] = cb[j][x - 1] = cc[i / 3 * 3 + j / 3][x - 1] = false;
}
return false;
}
}十、黄金矿工
你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为 m * n 的网格 grid 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量；如果该单元格是空的，那么就是 0。
为了使收益最大化，矿工需要按以下规则来开采黄金：
- 每当矿工进入一个单元，就会收集该单元格中的所有黄金。
- 矿工每次可以从当前位置向上下左右四个方向走。
- 每个单元格只能被开采（进入）一次。
- 不得开采（进入）黄金数目为
0的单元格。 - 矿工可以从网格中 任意一个 有黄金的单元格出发或者是停止。
示例 1：
输入：grid = [[0,6,0],[5,8,7],[0,9,0]] 输出：24 解释： [[0,6,0], [5,8,7], [0,9,0]] 一种收集最多黄金的路线是：9 -> 8 -> 7。
示例 2：
输入：grid = [[1,0,7],[2,0,6],[3,4,5],[0,3,0],[9,0,20]] 输出：28 解释： [[1,0,7], [2,0,6], [3,4,5], [0,3,0], [9,0,20]] 一种收集最多黄金的路线是：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7。
提示：
1 <= grid.length, grid[i].length <= 150 <= grid[i][j] <= 100- 最多 25 个单元格中有黄金。
解法一：深度优先搜索 + 回溯
class Solution {
public int getMaximumGold(int[][] grid) {
int m = grid.length, n = grid[0].length;
int maxGold = 0;
// 遍历整个网格，如果一个单元格有黄金，就从该单元格开始进行深度优先搜索
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] > 0) {
int[] visited = new int[m * n];
maxGold = Math.max(maxGold, dfs(grid, i, j, visited));
}
}
}
return maxGold;
}
/**
* 深度优先遍历
*
* @param grid
* @param i
* @param j
* @param visited
* @return
*/
private int dfs(int[][] grid, int i, int j, int[] visited) {
int m = grid.length, n = grid[0].length;
// 二维数组在一维数组中的位置
int index = i * n + j;
if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == 0 || visited[index] == 1) {
// 检查单元格是否合法
return 0;
}
visited[index] = 1;
int gold = grid[i][j] + Math.max(Math.max(dfs(grid, i + 1, j, visited), dfs(grid, i - 1, j, visited)),
Math.max(dfs(grid, i, j + 1, visited), dfs(grid, i, j - 1, visited)));
// 回溯
visited[index] = 0;
return gold;
}
}
扫一扫
597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
