一、基础理论
1.1 什么是回溯法
回溯法也可以叫做回溯搜索法，它是一种搜索的方式。在二叉树系列中，我们已经不止一次，提到了回溯，二叉树的递归中隐藏着回溯。
回溯是递归的副产品，只要有递归就会有回溯。
1.2 回溯法的效率
回溯法的性能如何呢，这里要和大家说清楚了，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。
因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。
那么既然回溯法并不高效为什么还要用它呢？因为没得选，一些问题能暴力搜出来就不错了，撑死了再剪枝一下，还没有更高效的解法。
1.3 回溯法解决的问题
回溯法，一般可以解决如下几种问题：
- 组合问题：N个数里面按一定规则找出k个数的集合
- 切割问题：一个字符串按一定规则有几种切割方式
- 子集问题：一个N个数的集合里有多少符合条件的子集
- 排列问题：N个数按一定规则全排列，有几种排列方式
- 棋盘问题：N皇后，解数独等等
相信大家看着这些之后会发现，每个问题，都不简单！
另外，会有一些同学可能分不清什么是组合，什么是排列？组合是不强调元素顺序的，排列是强调元素顺序。例如：{1, 2} 和 {2, 1} 在组合上，就是一个集合，因为不强调顺序，而要是排列的话，{1, 2} 和 {2, 1} 就是两个集合了。
以下是回溯算法的问题分类以及对应的leetcode题目编号：
1.4 如何理解回溯算法
回溯法解决的问题都可以抽象为树形结构 ，是的，我指的是所有回溯法的问题都可以抽象为树形结构！因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度就构成了树的深度。
递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。
1.5 回溯法模版
java
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}这份模板很重要，后面做回溯法的题目都靠它了！
1. 回溯函数模板返值以及参数
在回溯算法中，我的习惯是函数起名字为backtracking，这个起名大家随意。回溯算法中函数返回值一般为void。再来看一下参数，因为回溯算法需要的参数可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，然后需要什么参数，就填什么参数。
2. 回溯函数终止条件
什么时候达到了终止条件，树中就可以看出，一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。
3. 回溯搜索的遍历过程
回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。如图：
for循环就是遍历集合区间，可以理解一个节点有多少个孩子，这个for循环就执行多少次。
backtracking这里自己调用自己，实现递归。
大家可以从图中看出for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。
二、leetcode例题详解
2.1 全排列
leetcode题目链接：46. 全排列
给定一个不含重复数字的数组
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]]解法：
java
/**
* 解决全排列问题
* 给定一个不含重复数字的数组 nums，返回其所有可能的全排列
*
* @param nums 输入的不含重复数字的数组
* @return 返回数组的所有全排列
* @throws IllegalArgumentException 如果输入数组为null，则抛出此异常
*/
public List<List<Integer>> permute(int[] nums) {
// 输入校验
if (nums == null) {
throw new IllegalArgumentException("Input array cannot be null");
}
List<List<Integer>> result = new ArrayList<>();
if (nums.length == 0) {
// 空数组的全排列是一个空列表
result.add(new ArrayList<>());
return result;
}
backtrack(nums, new boolean[nums.length], new ArrayList<>(), result);
return result;
}
/**
* 回溯法生成全排列
*
* @param nums 原始数组
* @param used 标记数组，表示某个数字是否已被使用
* @param current 当前正在构建的排列
* @param result 存储所有排列的结果列表
*/
private void backtrack(int[] nums, boolean[] used, List<Integer> current, List<List<Integer>> result) {
// 当前排列已完成
if (current.size() == nums.length) {
result.add(new ArrayList<>(current));
return;
}
// 尝试每个数字
for (int i = 0; i < nums.length; i++) {
if (used[i]) {
// 已使用的数字跳过
continue;
}
// 标记当前数字为已使用
used[i] = true;
// 加入当前排列
current.add(nums[i]);
// 递归生成下一个排列
backtrack(nums, used, current, result);
// 回溯，移除最后一个数字
current.remove(current.size() - 1);
// 解除标记
used[i] = false;
}
}2.2 子集
leetcode题目链接：78. 子集
给你一个整数数组
nums，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]示例 2：
输入：nums = [0]
输出：[[],[0]]解法：
java
/**
* 生成给定数组的所有子集
*
* @param nums 输入的整数数组
* @return 包含所有子集的列表
* @throws IllegalArgumentException 如果输入数组为 null
*/
public List<List<Integer>> subsets(int[] nums) {
// 1. 输入校验
if (nums == null) {
throw new IllegalArgumentException("Input array cannot be null");
}
List<List<Integer>> result = new ArrayList<>();
// 通过回溯算法生成所有子集
backtrack(nums, 0, new ArrayList<>(), result);
return result;
}
/**
* 回溯算法生成所有子集
*
* @param nums 输入的整数数组
* @param start 标记当前递归中可以选取的起始索引，确保不会重复使用之前的元素
* @param currentSubset 当前正在生成的子集
* @param result 存储所有子集的结果列表
*/
private void backtrack(int[] nums, int start, List<Integer> currentSubset, List<List<Integer>> result) {
// 2. 将当前子集加入结果集
result.add(new ArrayList<>(currentSubset));
// 3. 遍历剩余元素，生成所有可能的子集（每次递归时，从start开始遍历数组，避免重复选择）
for (int i = start; i < nums.length; i++) {
// 选择当前元素
currentSubset.add(nums[i]);
// 递归生成子集，注意i+1，避免重复选择
backtrack(nums, i + 1, currentSubset, result);
// 撤销选择
currentSubset.remove(currentSubset.size() - 1);
}
}2.3 电话号码的字母组合
leetcode题目链接：17. 电话号码的字母组合
给定一个仅包含数字
2-9的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]示例 2：
输入：digits = ""
输出：[]示例 3：
输入：digits = "2"
输出：["a","b","c"]解法：
java
// 定义数字到字母的映射关系
private static final Map<Character, String> DIGIT_TO_LETTERS = new HashMap<Character, String>() {{
put('2', "abc");
put('3', "def");
put('4', "ghi");
put('5', "jkl");
put('6', "mno");
put('7', "pqrs");
put('8', "tuv");
put('9', "wxyz");
}};
/**
* 根据数字字符串获取所有可能的字母组合
* 每个数字对应手机键盘上的字母
*
* @param digits 数字字符串，如 "23"
* @return 所有可能的字母组合列表
*/
public List<String> letterCombinations(String digits) {
// 输入校验
if (digits == null || digits.isEmpty()) {
return new ArrayList<>(); // 返回空列表
}
// 确保输入只包含有效数字
for (char c : digits.toCharArray()) {
if (!DIGIT_TO_LETTERS.containsKey(c)) {
return new ArrayList<>(); // 非法输入返回空列表
}
}
// 调用递归方法生成组合
List<String> result = new ArrayList<>();
backtrack(result, new StringBuilder(), digits, 0);
return result;
}
/**
* 递归回溯生成字母组合
*
* @param result 结果列表，用于收集所有组合
* @param combination 当前组合，用于构建组合
* @param digits 数字字符串，作为输入
* @param index 当前处理的数字索引
*/
private void backtrack(List<String> result, StringBuilder combination, String digits, int index) {
// 当前组合完成，添加到结果列表
if (index == digits.length()) {
result.add(combination.toString());
return;
}
// 获取当前数字对应的所有可能字母
char digit = digits.charAt(index);
String letters = DIGIT_TO_LETTERS.get(digit);
// 遍历当前数字对应的所有字母
for (char letter : letters.toCharArray()) {
combination.append(letter); // 选择
backtrack(result, combination, digits, index + 1); // 递归
combination.deleteCharAt(combination.length() - 1); // 撤销选择
}
}2.4 组合总和
leetcode题目链接：39. 组合总和
给你一个 无重复元素 的整数数组
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
输出: []解法：
java
/**
* 解决组合总和问题，找出所有候选数字中所有和为 target 的组合
* candidates 中的数字可以无限制重复被选取
*
* @param candidates 候选数字数组
* @param target 目标和
* @return 所有和为 target 的组合
*/
public List<List<Integer>> combinationSum(int[] candidates, int target) {
// 检查输入是否合法
if (candidates == null || candidates.length == 0 || target < 0) {
return new ArrayList<>();
}
// 对候选数组进行排序，便于后续剪枝
Arrays.sort(candidates);
List<List<Integer>> result = new ArrayList<>();
// 调用回溯函数，从第一个数字开始寻找所有可能的组合
backtrack(candidates, target, 0, new ArrayList<>(), result);
return result;
}
/**
* 回溯函数，用于寻找所有和为 target 的组合
*
* @param candidates 候选数字数组
* @param remaining 当前剩余的目标和
* @param start 当前搜索的起始索引，避免重复组合
* @param currentCombination 当前的数字组合
* @param result 存储所有符合条件的组合的列表
*/
private void backtrack(int[] candidates, int remaining, int start, List<Integer> currentCombination, List<List<Integer>> result) {
// 如果剩余值为 0，说明找到了一个有效的组合
if (remaining == 0) {
result.add(new ArrayList<>(currentCombination));
return;
}
// 遍历候选数组，从 start 开始避免重复组合
for (int i = start; i < candidates.length; i++) {
// 剪枝：如果当前候选数字大于剩余值，则直接跳过后续更大的数字
if (candidates[i] > remaining) {
break;
}
// 将当前数字加入组合
currentCombination.add(candidates[i]);
// 递归调用，继续寻找剩余值的组合
backtrack(candidates, remaining - candidates[i], i, currentCombination, result);
// 回溯：移除最后一个加入的数字，尝试其他可能性
currentCombination.remove(currentCombination.size() - 1);
}
}2.5 括号生成
leetcode题目链接：22. 括号生成
数字
n代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]示例 2：
输入：n = 1
输出：["()"]解法：
java
/**
* 生成所有可能的 n 对括号的组合
*
* @param n 指定的括号对数
* @return 包含所有可能括号组合的列表
* @throws IllegalArgumentException 如果输入的 n 小于 0
*/
public List<String> generateParenthesis(int n) {
// 边界条件：如果 n 小于 0，直接返回空列表
if (n < 0) {
throw new IllegalArgumentException("Input must be a non-negative integer.");
}
// 如果 n 等于 0，返回包含空字符串的列表
if (n == 0) {
return Collections.singletonList("");
}
List<String> result = new ArrayList<>();
backtrack(result, "", 0, 0, n);
return result;
}
/**
* 回溯函数，用于生成所有有效的括号组合
*
* @param result 结果列表，存储所有有效的括号组合
* @param current 当前生成的括号字符串
* @param open 已经放置的左括号数量
* @param close 已经放置的右括号数量
* @param max 总共需要生成的括号对数
*/
private void backtrack(List<String> result, String current, int open, int close, int max) {
// 如果当前字符串长度达到 2 * max，则将其加入结果列表
if (current.length() == 2 * max) {
result.add(current);
return;
}
// 添加左括号的条件：左括号数量小于 max
if (open < max) {
backtrack(result, current + "(", open + 1, close, max);
}
// 添加右括号的条件：右括号数量小于左括号数量
if (close < open) {
backtrack(result, current + ")", open, close + 1, max);
}
}
/**
* 上述方法没有"撤销"操作？
* 上述方法中没有显示的"撤销"操作，但通过递归调用和函数栈的特性，隐式地实现了回溯的过程。每次递归返回时，状态会自动恢复到调用递归前的状态，从而完成回溯。
* 以下方法使用stringBuilder替代String，以便显式地修改和恢复状态，在每次递归调用前后，显式地添加和删除括号，体现回溯过程。
* @param result
* @param current
* @param open
* @param close
* @param max
*/
private void backtrack(List<String> result, StringBuilder current, int open, int close, int max) {
// 如果当前字符串长度达到 2 * max，则将其加入结果列表
if (current.length() == 2 * max) {
result.add(current.toString());
return;
}
// 添加左括号的条件：左括号数量小于 max
if (open < max) {
current.append("("); // 做出选择
backtrack(result, current, open + 1, close, max);
current.deleteCharAt(current.length() - 1); // 撤销选择
}
// 添加右括号的条件：右括号数量小于左括号数量
if (close < open) {
current.append(")"); // 做出选择
backtrack(result, current, open, close + 1, max);
current.deleteCharAt(current.length() - 1); // 撤销选择
}
}2.6 单词搜索
leetcode题目链接：79. 单词搜索
给定一个
m x n二维字符网格board和一个字符串单词word。如果word存在于网格中，返回true；否则，返回false。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中"相邻"单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
示例 1：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true示例 2：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
输出：true示例 3：
输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
输出：false解法：
java
// 定义四个方向：右、下、左、上，用于DFS搜索
private static final int[][] DIRECTIONS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
/**
* 在二维字符网格中查找是否存在串联成给定单词的字母序列
* @param board 二维字符网格
* @param word 待查找的单词
* @return 如果能找到则返回true，否则返回false
*/
public boolean exist(char[][] board, String word) {
// 检查输入的边界条件，包括空值和空字符串
if (board == null || board.length == 0 || board[0].length == 0 || word == null || word.isEmpty()) {
return false;
}
int rows = board.length;
int cols = board[0].length;
// 遍历二维网格的每个单元格
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
// 如果当前单元格的字母是单词的起始字母，开始深度优先搜索
if (dfs(board, word, i, j, 0)) {
return true;
}
}
}
// 如果所有路径都搜索完毕仍未找到匹配的单词，返回false
return false;
}
/**
* 使用深度优先搜索（DFS）在网格中查找单词
* @param board 二维字符网格
* @param word 待查找的单词
* @param row 当前搜索的行位置
* @param col 当前搜索的列位置
* @param index 当前匹配到的单词中的字母索引
* @return 如果能找到匹配的单词则返回true，否则返回false
*/
private boolean dfs(char[][] board, String word, int row, int col, int index) {
// 检查当前位置是否超出网格边界或与当前匹配的字母不符
if (row < 0 || row >= board.length || col < 0 || col >= board[0].length
|| board[row][col] != word.charAt(index)) {
return false;
}
// 如果当前字母索引是单词的最后一个，且匹配成功，说明找到了完整的单词
if (index == word.length() - 1) {
return true;
}
// 暂存当前位置的字符，并标记为已访问，避免重复搜索
char temp = board[row][col];
// 注意：容易出错的地方
board[row][col] = '#';
// 向四个方向递归搜索下一个字母
for (int[] direction : DIRECTIONS) {
int newRow = row + direction[0];
int newCol = col + direction[1];
if (dfs(board, word, newRow, newCol, index + 1)) {
return true;
}
}
// 搜索完成后恢复当前位置的字符，以便其他路径可以访问
board[row][col] = temp;
// 如果所有方向的搜索都未成功，返回false
return false;
}2.7 分割回文串
leetcode题目链接：131. 分割回文串
给你一个字符串
s，请你将s分割成一些 子串，使每个子串都是 回文串 。返回s所有可能的分割方案。
示例 1：
输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]示例 2：
输入：s = "a"
输出：[["a"]]解法：
java
/**
* 对字符串进行所有可能的回文分割
*
* @param s 待分割的字符串
* @return 所有可能的回文分割方案
*
* 本函数使用回溯算法，找出所有可能的回文分割方式
*/
public List<List<String>> partition(String s) {
// 1. 输入校验
if (s == null) {
throw new IllegalArgumentException("Input string cannot be null");
}
// 2. 边界条件处理
List<List<String>> result = new ArrayList<>();
if (s.length() == 0) {
result.add(new ArrayList<>()); // 返回 [[]] 表示空字符串的分割结果
return result;
}
// 3. 使用回溯法实现分割逻辑
backtrack(s, 0, new ArrayList<>(), result);
return result;
}
/**
* 回溯法实现字符串分割
*
* @param s 待分割的字符串
* @param start 当前分割的起始位置
* @param currentPartition 当前的分割方案
* @param result 保存所有分割方案的结果集
*
* 本函数尝试从当前分割位置开始，找到所有可能的回文子串，并继续递归分割剩余部分
*/
private void backtrack(String s, int start, List<String> currentPartition, List<List<String>> result) {
// 当前分割到达字符串末尾时，将当前分割方案加入结果
if (start == s.length()) {
result.add(new ArrayList<>(currentPartition));
return;
}
// 尝试从当前起点分割出所有可能的回文子串
for (int end = start + 1; end <= s.length(); end++) {
String substring = s.substring(start, end);
if (isPalindrome(substring)) { // 如果是回文子串，则继续递归
currentPartition.add(substring); // 做选择
backtrack(s, end, currentPartition, result); // 递归
currentPartition.remove(currentPartition.size() - 1); // 撤销选择
}
}
}
/**
* 判断字符串是否为回文
*
* @param s 待判断的字符串
* @return true 如果字符串是回文，否则返回 false
*
* 本函数通过双指针法，从两端向中间检查字符是否相同来判断是否为回文
*/
private boolean isPalindrome(String s) {
int left = 0, right = s.length() - 1;
while (left < right) {
if (s.charAt(left) != s.charAt(right)) {
return false;
}
left++;
right--;
}
return true;
}2.8 N皇后
leetcode题目链接：51. 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"]]解法：
java
/**
* 解决N皇后问题的主方法
*
* @param n 皇后的数量
* @return 所有可能的解决方案
*/
public List<List<String>> solveNQueens(int n) {
List<List<String>> result = new ArrayList<>();
if (n <= 0) {
return result;
}
int[] queens = new int[n];
solveNQueens(result, queens, 0, n);
return result;
}
/**
* 递归解决N皇后问题的辅助方法
*
* @param result 结果集，用于存储所有可能的解决方案
* @param queens 用于记录每行皇后的位置，queens[i]=j 表示第i行皇后的位置是第j列
* @param row 当前处理的行号
* @param n 皇后的数量
*/
private void solveNQueens(List<List<String>> result, int[] queens, int row, int n) {
if (row == n) {
result.add(generateBoard(queens, n));
return;
}
for (int col = 0; col < n; col++) {
if (isValid(queens, row, col)) {
queens[row] = col;
solveNQueens(result, queens, row + 1, n);
}
}
}
/**
* 检查当前位置是否可以放置皇后
*
* @param queens 用于记录每行皇后的位置
* @param row 当前处理的行号
* @param col 当前处理的列号
* @return 当前位置是否有效
*/
private boolean isValid(int[] queens, int row, int col) {
// 为什么只遍历到row-1？因为在回溯的过程中row以及row之后的行还没有放置皇后
for (int i = 0; i < row; i++) {
// queens[i] == col，说明在同一列上有皇后
// Math.abs(queens[i] - col) == Math.abs(i - row)， 说明在对角线上有皇后
// 同一行是否有皇后？在回溯的过程中就已经避免了不会存在皇后，所以只需要检查同一列以及对角线是否有皇后
if (queens[i] == col || Math.abs(queens[i] - col) == Math.abs(i - row)) {
return false;
}
}
return true;
}
/**
* 根据皇后的放置情况生成棋盘
*
* @param queens 用于记录每行皇后的位置
* @param n 皇后的数量
* @return 生成的棋盘
*/
private List<String> generateBoard(int[] queens, int n) {
List<String> board = new ArrayList<>();
for (int row = 0; row < n; row++) {
StringBuilder sb = new StringBuilder();
for (int col = 0; col < n; col++) {
if (queens[row] == col) {
sb.append('Q');
} else {
sb.append('.');
}
}
board.add(sb.toString());
}
return board;
}