回溯类题目专题训练 -- LeetCode上12道与回溯相关的题
这个专题中的题目是我跟随代码随想录的刷题计划，在LeetCode上做的与回溯相关的题目，用于加深对回溯的理解！
下面的内容将会有每一道题目的题意、在代码随想录中对应的参考文章、我的思路以及我所写的Java代码，希望对你有帮助！
目录
-
- 1 - LeetCode 77 组合 -- 回溯法
- 2 - LeetCode 216 组合总和 III -- 回溯法
- 3 - LeetCode 17 电话号码的字母组合 -- 回溯法
- 4 - LeetCode 39 组合总和 -- 回溯法
- 5 - LeetCode 40 组合总和 II -- 回溯法
- 6 - LeetCode 131 分割回文串 -- 回溯法
- 7 - LeetCode 93 复原IP地址 -- 回溯法
- 8 - LeetCode 78子集 -- 回溯法
- 9 - LeetCode 90 子集 II -- 回溯法
- 10 - LeetCode 491 递增子序列 -- 回溯法
- 11 - LeetCode 46 全排列 -- 回溯法
- 12 - LeetCode 47 全排列 II -- 回溯法
1 - LeetCode 77 组合 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combinations
题意：
给定两个整数 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 <= 20
1 <= k <= n
参考文章
思路：
这道题目是回溯算法类的题目，关于回溯算法，可以阅读代码随想录的这篇文章《回溯算法理论基础！》做一个初步了解。
回溯算法模板框架：
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
本题直接套用回溯算法的模板即可（图片转自代码随想录）
至于在for循环中的 i <= n - (k - path.size()) + 1为什么这样写，可以看参考文章中剪枝优化部门的讲解。
本题Java代码：
class Solution {
List<List<Integer>> ans = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
private void backTracking(int n, int k, int start) {
if (path.size() == k) {
ans.add(new ArrayList<>(path));
return;
}
for (int i = start; i <= n - (k - path.size()) + 1; i++) {
path.add(i);
backTracking(n, k, i + 1);
path.removeLast();
}
}
public List<List<Integer>> combine(int n, int k) {
backTracking(n, k, 1);
return ans;
}
}
2 - LeetCode 216 组合总和 III – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-iii
题意：
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
所有数字都是正整数。
解集不能包含重复的组合。
示例 1:
输入: k = 3, n = 7
输出: [[1,2,4]]
示例 2:
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
参考文章
思路：
其实要是做了《LeetCode 77 组合》这道题，本题其实是更加容易的，都是使用回溯法且做了简单的剪枝。
本题的剪枝体现在for循环中sum+i<=n这个条件语句上。
本题Java代码：
class Solution {
int sum;
List<List<Integer>> ans = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
private void backTracking(int k, int n, int start) {
if (path.size() == k) {
if (sum == n) ans.add(new ArrayList<>(path));
return;
}
for (int i = start; i <= 9 && sum + i <= n; i++) {
path.add(i);
sum += i;
backTracking(k, n, i + 1);
sum -= i;
path.removeLast();
}
}
public List<List<Integer>> combinationSum3(int k, int n) {
backTracking(k, n, 1);
return ans;
}
}
3 - LeetCode 17 电话号码的字母组合 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number
题意：
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]
示例 2：
输入：digits = “”
输出：[]
示例 3：
输入：digits = “2”
输出：[“a”,“b”,“c”]
提示：
0 <= digits.length <= 4
digits[i] 是范围 [‘2’, ‘9’] 的一个数字。
参考文章
思路：
这是一道回溯类题目，直接套用回溯模板代码，不难写出代码。
本题Java代码：
class Solution {
private StringBuilder tmp = new StringBuilder();
private List<String> ans = new ArrayList<>();
private String[] word = new String[]{"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
private void search(String digits, int start) {
if (start == digits.length()) {
ans.add(tmp.toString());
return;
}
for (int i = 0; i < word[digits.charAt(start) - '0' - 2].length(); i++) {
tmp.append(word[digits.charAt(start) - '0' - 2].charAt(i));
search(digits, start + 1);
tmp.deleteCharAt(tmp.length() - 1);
}
}
public List<String> letterCombinations(String digits) {
if (digits.length() == 0) return ans;
search(digits, 0);
return ans;
}
}
4 - LeetCode 39 组合总和 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum
题意：
给你一个 无重复元素 的整数数组 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 <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都 互不相同
1 <= target <= 500
参考文章
思路：
本题与上诉两题的区别在于可以无限重复取同一个值且组合没有数量要求，既然所有元素都是正数，那么我们只要加入判断当前和是否大于目标值即可。
那么沿着这个思路，我们甚至可以进行剪枝。在求和问题中，排序之后加剪枝是常见的套路！ 我们先对集合进行排序，然后在递归中，当我们发现当前和大于目标值，就可以不再进入下一层递归！
本题Java代码：
class Solution {
private int sum;
private List<List<Integer>> ans = new ArrayList<>();
private LinkedList<Integer> path = new LinkedList<>();
private void backTracking(int[] candidates, int target, int start) {
if (sum == target) {
ans.add(new ArrayList<>(path));
return;
}
for (int i = start; i < candidates.length; i++) {
if (sum + candidates[i] > target) return;
sum += candidates[i];
path.add(candidates[i]);
backTracking(candidates, target, i);
sum -= candidates[i];
path.removeLast();
}
}
public List<List<Integer>> combinationSum(int[] candidates, int target) {
Arrays.sort(candidates);
backTracking(candidates, target, 0);
return ans;
}
}
5 - LeetCode 40 组合总和 II – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum-ii
题意：
给定一个候选人编号的集合 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 <= 100
1 <= candidates[i] <= 50
1 <= target <= 30
参考文章
思路：
这道题的难点在于可能会出现重复取的情况（图片转自代码随想录）。
其实我们在每一层递归方法的for循环当中，如果当前 i 大于start且candidates[i] == candidates[i-1]，说明在当前树层中重复找到了同一个值，这个值是不可以取的！
本题Java代码：
class Solution {
private List<List<Integer>> ans = new ArrayList<>();
private LinkedList<Integer> path = new LinkedList<>();
private int sum;
private void backTracking(int[] candidates, int target, int start) {
if (sum == target) {
ans.add(new ArrayList<>(path));
return;
}
for (int i = start; i < candidates.length; i++) {
if (candidates[i] + sum > target) return;
if (i > start && candidates[i] == candidates[i - 1]) continue;//关键代码在这一句
sum += candidates[i];
path.add(candidates[i]);
backTracking(candidates, target, i + 1);
sum -= candidates[i];
path.removeLast();
}
}
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
backTracking(candidates, target, 0);
return ans;
}
}
6 - LeetCode 131 分割回文串 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-partitioning
题意：
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例 1：
输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]
示例 2：
输入：s = “a”
输出：[[“a”]]
提示：
1 <= s.length <= 16
s 仅由小写英文字母组成
参考文章
思路：
切割问题可以抽象为组合问题，这道题我们对字符串中的字符按顺序考虑组合，并判断是否是回文串，如果是，则进行切割。
切割方法使用传递下标的方法，比直接重新建立String对象更快。
判断是否回文串使用到了双指针。
本题Java代码：
class Solution {
List<List<String>> ans = new ArrayList<>();
LinkedList<String> path = new LinkedList<>();
private void backTracking(String s, int start) {
if (start >= s.length()) {
ans.add(new ArrayList<>(path));
return;
}
for (int i = start; i < s.length(); i++) {
if (isVaild(s, start, i)) {
path.add(s.substring(start, i + 1));
backTracking(s, i + 1);
path.removeLast();
}
}
}
private boolean isVaild(String s, int start, int last) {
for (int i = start, j = last; i <= j; i++, j--) {
if (s.charAt(i) != s.charAt(j)) return false;
}
return true;
}
public List<List<String>> partition(String s) {
backTracking(s, 0);
return ans;
}
}
7 - LeetCode 93 复原IP地址 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/restore-ip-addresses
题意：
有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “[email protected]” 是 无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。
示例 1：
输入：s = “25525511135”
输出：[“255.255.11.135”,“255.255.111.35”]
示例 2：
输入：s = “0000”
输出：[“0.0.0.0”]
示例 3：
输入：s = “101023”
输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]
提示：
1 <= s.length <= 20
s 仅由数字组成
参考文章
思路：
这道题与《LeetCode 131 分割回文串》很像，都是使用回溯法，对字符串使用下标进行切割，并判断字符串子串是否符合某种规则。同时本题在回溯法中还使用到了字符串的拼接，可以算是小的加强版。
判断是否符合IP地址的规则：
1、不能有前导0
2、数字小于255
3、不能有非正整数字符
本题Java代码：
class Solution {
private List<String> ans = new ArrayList<>();
private int point;
private void backTracking(String s, int start) {
if (point == 3 && isVaild(s, start, s.length() - 1)) {
ans.add(s);
return;
}
for (int i = start; i < s.length(); i++) {
if (isVaild(s, start, i)) {
s = s.substring(0, i + 1) + "." + s.substring(i + 1, s.length());
point++;
backTracking(s, i + 2);
point--;
s = s.substring(0, i + 1) + s.substring(i + 2, s.length());
}
}
}
private boolean isVaild(String s, int start, int last) {
if (start > last || last - start > 2) return false;
if (start != last && s.charAt(start) == '0') return false;
int num = 0;
for (int i = start; i <= last; i++) {
if (s.charAt(i) < '0' || s.charAt(i) > '9') return false;
num = num * 10 + (s.charAt(i) - '0');
}
if (num > 255) return false;
return true;
}
public List<String> restoreIpAddresses(String s) {
if (s.length() > 12) return ans;
backTracking(s, 0);
return ans;
}
}
8 - LeetCode 78子集 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subsets
题意：
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
提示：
1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的所有元素 互不相同
参考文章
思路：
这道题与《LeetCode 77 组合》其实是十分相似的，也都同样是模板题。它们仅仅的区别在于，求子集，回溯算法中非叶子节点的值也要保存到结果数组中。只要将求子集的过程和求组合的过程一对比，就很清晰明了了。
求子集的过程（图片转自代码随想录）：
求组合的过程（图片转自代码随想录）：
那么我们只需要在求组合的代码模板中将当前元素加入到答案数组的条件语句去掉即可！差别处在以下代码中已注明！
本题Java代码：
class Solution {
private List<List<Integer>> ans = new ArrayList<>();
private LinkedList<Integer> path = new LinkedList<>();
private void backTracking(int[] nums, int start) {
ans.add(new ArrayList<>(path));//区别处！
for (int i = start; i < nums.length; i++) {
path.add(nums[i]);
backTracking(nums, i + 1);
path.removeLast();
}
}
public List<List<Integer>> subsets(int[] nums) {
backTracking(nums, 0);
return ans;
}
}
9 - LeetCode 90 子集 II – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subsets-ii
题意：
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
示例 1：
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
输入：nums = [0]
输出：[[],[0]]
提示：
1 <= nums.length <= 10
-10 <= nums[i] <= 10
参考文章
思路：
这道题涉及到两个问题：
1、一个是选子集问题，这个部分与《LeetCode 78子集》这道题一致，请一定要先做这道题
2、另一个是回溯算法去重问题，这个部分与《LeetCode 40 组合总和 II》这道题一致，是同一个去重套路！
上述两道题目做过的话，这道题直接迎刃而解！
本题Java代码：
class Solution {
private List<List<Integer>> ans = new ArrayList<>();
private LinkedList<Integer> path = new LinkedList<>();
private void backTracking(int[] nums, int start) {
ans.add(new ArrayList<>(path));
for (int i = start; i < nums.length; i++) {
if (i > start && nums[i] == nums[i - 1]) continue;
path.add(nums[i]);
backTracking(nums, i + 1);
path.removeLast();
}
}
public List<List<Integer>> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
backTracking(nums, 0);
return ans;
}
}
10 - LeetCode 491 递增子序列 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/increasing-subsequences
题意：
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。
数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
示例 1：
输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2：
输入：nums = [4,4,3,2,1]
输出：[[4,4]]
提示：
1 <= nums.length <= 15
-100 <= nums[i] <= 100
参考文章
思路：
这道题主要是不能像《LeetCode 90 子集 II》一样去使用给元素排序的方式来去重，因为这道题是要找原本序列中的递增子序列！！！
鉴于这道题中数字范围在 -100 ~ 100 中，因此我们直接使用一个boolean数组来记录当前回溯树层中这个数是否已经用过了。
注意：isUsed数组是记录本层元素是否重复使用，新的一层isUsed数组都会重新定义（清空），所以要知道isUsed数组只负责本层！ 因此isUsed数组应该声明为局部变量，而不是全局变量！且因为每次递归都是在每一层当中，因此在递归方法中，一旦isUsed数组中某个元素设为true，在回溯时候不再设为false！
判断当前回溯树层中这个数是否已经用过的过程参考以下图片（图片转自代码随想录）：
本题Java代码：
class Solution {
private List<List<Integer>> ans = new ArrayList<>();
private List<Integer> path = new ArrayList<>();
private void backTracking(int[] nums, int start) {
if (path.size() > 1) ans.add(new ArrayList<>(path));
boolean[] isUsed = new boolean[201];
for (int i = start; i < nums.length; i++) {
if ((path.isEmpty() || (nums[i] >= path.get(path.size() - 1))) && isUsed[nums[i] + 100] == false) {
isUsed[nums[i] + 100] = true;
path.add(nums[i]);
backTracking(nums, i + 1);
path.remove(path.size() - 1);
}
}
}
public List<List<Integer>> findSubsequences(int[] nums) {
backTracking(nums, 0);
return ans;
}
}
11 - LeetCode 46 全排列 – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutations
题意：
给定一个不含重复数字的数组 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] <= 10
nums 中的所有整数 互不相同
参考文章
思路：
本题也是回溯算法用于排列问题的模板题。先比《LeetCode 77 组合》中的组合问题，排列问题的差别在于：
- 每层都是从0开始搜索而不是startIndex
- 需要used数组记录path里都放了哪些元素，以免重复排列同一个数字
因此对回溯算法组合问题的模板做简单修改，即可使用回溯算法解决排列问题。（修改点已注明在代码中）
截至本题，我们可以发现，回溯算法可以用于解决组合、字符串切割、子集、排列等的相关问题
以组合问题中的回溯算法模板为例：
- 字符串切割问题同样可以视为组合问题
- 子集问题和组合问题差别在于子集问题答案中需要包含回溯算法树形中的非叶子节点
- 排列问题和组合问题差别在于排列问题for循环下标从0开始搜索且需要使用used数组记录
本题Java代码：
class Solution {
private List<List<Integer>> ans = new ArrayList<>();
private LinkedList<Integer> path = new LinkedList<>();
private boolean[] isUsed;
private void backTracking(int[] nums) {
if (path.size() >= nums.length) {
ans.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {//与组合问题的差别处：i从0开始
if (isUsed[i] == true) continue;//与组合问题的差别处：使用used数组
isUsed[i] = true;
path.add(nums[i]);
backTracking(nums);
path.removeLast();
isUsed[i] = false;
}
}
public List<List<Integer>> permute(int[] nums) {
isUsed = new boolean[nums.length];
backTracking(nums);
return ans;
}
}
12 - LeetCode 47 全排列 II – 回溯法
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutations-ii
题意：
给定一个可包含重复数字的序列 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
参考文章
思路：
做这道题前需要先做《LeetCode 40 组合总和 II》和《LeetCode 46 全排列》这两道题。
这一题其实就是上面两道题的总和，使用回溯法解决全排列问题以及去重问题。
这里我要解读一下关键语句if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;（在代码上的位置已注明）。毕竟这个地方思考了我挺久。
为什么这个条件语句符合的话就跳过当前循环？
经过排序之后，如果 nums[i] == nums[i - 1]，说明当前数字与前一个数子相同，则会有以下情况：
- 如果 used[i - 1] == true，那么说明前一个数在其他树层已经取了，这个时候我们可以在当前层可以取当前数；
- 相反，如果 used[i - 1] == false，那么说明前一个数在其他树层没有取过，那么在这个for循环中，前一个数在当前树层已经取过了，那么我们就不能再取当前数了！
同样道理，如果我们判断语句写为if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true) continue;（将 used[i - 1] == false 修改为 used[i - 1] == true ），改为了在同一树枝上进行判断！
两种情况的详细对比看以下两个图（图片转自代码随想录）：
显然使用 used[i - 1] == false 的性能是更高的，而且我觉得写 used[i - 1] == false 也更容易理解！
本题Java代码：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
class Solution {
private List<List<Integer>> ans = new ArrayList<>();
private LinkedList<Integer> path = new LinkedList<>();
private boolean[] used;
private void backTracking(int[] nums) {
if (path.size() >= nums.length) {
ans.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;//关键语句
if (used[i] == true) continue;
used[i] = true;
path.add(nums[i]);
backTracking(nums);
path.removeLast();
used[i] = false;
}
}
public List<List<Integer>> permuteUnique(int[] nums) {
used = new boolean[nums.length];
Arrays.sort(nums);
backTracking(nums);
return ans;
}
}