文章目录
一、求子集问题
Leecode78
1.回溯三部曲
（1）确定递归函数参数及其返回值
返回值：不需要返回值，因为我们定义了全局变量数组path为子集收集元素，二维数组result存放子集组合。
参数：(int[] nums, int startIndex)其中nums是传入的数组，startIndex是起始点
（2）确定递归终止条件
剩余集合为空的时候，也就是startIndex已经大于数组的长度了，就终止了，因为没有元素可取了。
（3）确定单层搜索逻辑
for (int i = startIndex; i < nums.length; i++){
path.add(nums[i]);
subsetsHelper(nums, i + 1);
path.removeLast();
}
2.完整代码
class Solution {
List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
public List<List<Integer>> subsets(int[] nums) {
if (nums.length == 0){
result.add(new ArrayList<>());
return result;
}
subsetsHelper(nums, 0);
return result;
}
private void subsetsHelper(int[] nums, int startIndex){
result.add(new ArrayList<>(path));//「遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合」。
if (startIndex >= nums.length){ //终止条件可不加
return;
}
for (int i = startIndex; i < nums.length; i++){
path.add(nums[i]);
subsetsHelper(nums, i + 1);
path.removeLast();
}
}
}
3.作者链接
代码随想录
Leecode90
1.题目与分析
2.代码
used[i - 1] == true，说明同⼀树⽀nums[i - 1]使⽤过，used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过，为什么？
（上面的图里面used取值是0和1，1是true，0是false）
我是这样理解的，for循环保证了从数组中从前往后一个一个取值，再用if判断条件。所以nums[i - 1]一定比nums[i]先被取值和判断。如果nums[i - 1]被取值了，那used[i - 1]会被置1，只有当递归再回退到这一层时再将它置0。每递归一层都是在寻找数组对应于递归深度位置的值，每一层里用for循环来寻找。所以当used[i - 1] == 1时，说明nums[i - 1]和nums[i]分别属于两层递归中，也就是我们要用这两个数分别放在数组的两个位置，这时不需要去重。但是当used[i - 1] == 0时，说明nums[i - 1]和nums[i]属于同一层递归中（只是for循环进入下一层循环），也就是我们要用这两个数放在数组中的同一个位置上，这就是我们要去重的情况。
class Solution {
List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
boolean[] used;
public List<List<Integer>> subsetsWithDup(int[] nums) {
if (nums.length == 0){
result.add(path);
return result;
}
Arrays.sort(nums);
used = new boolean[nums.length];
subsetsWithDupHelper(nums, 0);
return result;
}
private void subsetsWithDupHelper(int[] nums, int startIndex){
result.add(new ArrayList<>(path));
if (startIndex >= nums.length){
return;
}
for (int i = startIndex; i < nums.length; i++){
if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
continue;
}
path.add(nums[i]);
used[i] = true;
subsetsWithDupHelper(nums, i + 1);
path.removeLast();
used[i] = false;
}
}
}
3.作者链接
代码随想录
二、排列问题
Solution46
1.题目
2.回溯三部曲
（1）递归函数参数
「首先排列是有序的，也就是说[1,2] 和[2,1] 是两个集合，这和之前分析的子集以及组合所不同的地方」。
可以看出元素1在[1,2]中已经使用过了，但是在[2,1]中还要在使用一次1，所以处理排列问题就不用使用startIndex了。
但排列问题需要一个used数组，标记已经选择的元素，如图橘黄色部分所示:
List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
boolean[] used;
private void permuteHelper(int[] nums)
（2）递归终止条件
可以看出叶子节点，就是收割结果的地方。那么什么时候，算是到达叶子节点呢？
当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。
if (path.size() == nums.length){
result.add(new ArrayList<>(path));
return;
}
（3）单层搜索的逻辑
for循环里不用startIndex了。因为排列问题，每次都要从头开始搜索，例如元素1在[1,2]中已经使用过了，但是在[2,1]中还要再使用一次1。
而used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次。
for (int i = 0; i < nums.length; i++){
if (used[i]){
continue;
}
used[i] = true;
path.add(nums[i]);
permuteHelper(nums);
path.removeLast();
used[i] = false;
}
3.完整代码
class Solution {
List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
boolean[] used;
public List<List<Integer>> permute(int[] nums) {
if (nums.length == 0){
return result;
}
used = new boolean[nums.length];
permuteHelper(nums);
return result;
}
private void permuteHelper(int[] nums){
if (path.size() == nums.length){
result.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++){
if (used[i]){
continue;
}
used[i] = true;
path.add(nums[i]);
permuteHelper(nums);
path.removeLast();
used[i] = false;
}
}
}
4.作者链接
代码随想录
Solution47
1.问题
为什么used[i - 1] == true说明同⼀树⽀nums[i - 1]使⽤过，used[i - 1] == false说明同⼀树层nums[i - 1]使⽤过？
（1是true，0是false）
我是这样理解的，for循环保证了从数组中从前往后一个一个取值，再用if判断条件。所以nums[i - 1]一定比nums[i]先被取值和判断。如果nums[i - 1]被取值了，那used[i - 1]会被置1，只有当递归再回退到这一层时再将它置0。每递归一层都是在寻找数组对应于递归深度位置的值，每一层里用for循环来寻找。所以当used[i - 1] == 1时，说明nums[i - 1]和nums[i]分别属于两层递归中，也就是我们要用这两个数分别放在数组的两个位置，这时不需要去重。但是当used[i - 1] == 0时，说明nums[i - 1]和nums[i]属于同一层递归中（只是for循环进入下一层循环），也就是我们要用这两个数放在数组中的同一个位置上，这就是我们要去重的情况。
2.代码
class Solution {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
boolean[] used;
public List<List<Integer>> permuteUnique(int[] nums) {
used = new boolean[nums.length];
Arrays.sort(nums);
backTrack(nums);
return result;
}
private void backTrack(int[] nums) {
if (path.size() == nums.length) {
result.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]) {
continue;
}
used[i] = true;
path.add(nums[i]);
backTrack(nums);
path.remove(path.size() - 1);
used[i] = false;//回溯
}
}
}
3.作者链接
代码随想录
三、组合问题
Solution77
1.题目
2.回溯三部曲
（1）递归函数的返回值以及参数
在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。
startIndex来记录下一层递归，搜索的起始位置。
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
private void combineHelper(int n, int k, int startIndex)
（2）回溯函数终止条件
if (path.size() == k){
result.add(new ArrayList<>(path));
return;
}
（3）单层搜索的过程
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){ // 控制树的横向遍历
path.add(i); // 处理节点
combineHelper(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
path.removeLast(); // 回溯，撤销处理的节点
}
（4）剪枝优化
3.完整代码
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> combine(int n, int k) {
combineHelper(n, k, 1);
return result;
}
/**
* 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
* @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
*/
private void combineHelper(int n, int k, int startIndex){
//终止条件
if (path.size() == k){
result.add(new ArrayList<>(path));
return;
}
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
path.add(i);
combineHelper(n, k, i + 1);
path.removeLast();
}
}
}
Solution17
1.问题描述
2.回溯三部曲
（1）确定回溯函数参数
backTracking(String digits, String[] numString, int num)
digits就是示例中的"23"
numString就是{"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}
num：对于digits的长度是n，那么num的取值就是从0到n-1，很容易理解嘛，为的就是渠道digits里的每一个数子
（2）确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。
那么终止条件就是如果num 等于 输入的数字个数（digits.size）了然后收集结果，结束本层递归。
if (num == digits.length()) {
list.add(temp.toString());
return;
}
（3）确定单层遍历逻辑
首先要取num指向的数字，并找到对应的字符集（手机键盘的字符集）。
注意本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而77. 组合和216.组合总和III都是是求同一个集合中的组合！
3.完整代码
class Solution {
//设置全局列表存储最后的结果
List<String> list = new ArrayList<>();
//每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild
StringBuilder temp = new StringBuilder();
public List<String> letterCombinations(String digits) {
if (digits == null || digits.length() == 0) {
return list;
}
//按键上2对应"abc",我们这里新增了两个无效的字符串""，那么numString[2]对应的也是"abc"
String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
backTracking(digits, numString, 0);
return list;
}
public void backTracking(String digits, String[] numString, int num) {
//遍历全部一次记录一次得到的字符串
if (num == digits.length()) {
list.add(temp.toString());
return;
}
//str 表示当前num对应的字符串
String str = numString[digits.charAt(num) - '0'];//将num指向的数字转为int，取数字对应的字符集
for (int i = 0; i < str.length(); i++) {
temp.append(str.charAt(i));
backTracking(digits, numString, num + 1);// 递归，注意num+1，一下层要处理下一个数字对应的字符集了
temp.deleteCharAt(temp.length() - 1);
}
}
}
4.作者链接
代码随想录
Solution39
1.问题描述
2.回溯三部曲
（1）递归函数参数
List<List<Integer>> res = new ArrayList<>();
List<Integer> path =new ArrayList<>();
public void backtracking(int[] candidates, int target, int sum, int idx)
这里依然是定义两个全局变量，二维数组result存放结果集，数组path存放符合条件的结果。
然后是题目中给出的参数，集合candidates, 和目标值target。
此外我还定义了int型的sum变量来统计单一结果path里的总和，其实这个sum也可以不用，用target做相应的减法就可以了，最后如果target==0就说明找到符合的结果了，但为了代码逻辑清晰，我依然用了sum。
本题还需要startIndex来控制for循环的起始位置，对于组合问题，什么时候需要startIndex呢？
如果是一个集合来求组合的话，就需要startIndex，例如：回溯算法：求组合问题！，回溯算法：求组合总和！。
如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：回溯算法：电话号码的字母组合
注意以上我只是说求组合的情况，如果是排列问题，又是另一套分析的套路。
（2）递归终止条件
// 找到了数字和为 target 的组合
if (sum == target) {
res.add(new ArrayList<>(path));
return;
}
（3）单层搜索的逻辑
单层for循环依然是从startIndex开始，搜索candidates集合。
本题元素为可重复选取的。如何重复选取呢，看代码，注释部分：
for (int i = idx; i < candidates.length; i++) {
// 如果 sum + candidates[i] > target 就终止遍历
if (sum + candidates[i] > target) break;
path.add(candidates[i]);
backtracking(res, path, candidates, target, sum + candidates[i], i);
path.remove(path.size() - 1); // 回溯，移除路径 path 最后一个元素
}
}
（4）剪枝优化
3.完整代码
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path =new ArrayList<>();
public List<List<Integer>> combinationSum(int[] candidates, int target) {
Arrays.sort(candidates); // 先进行排序
backtracking(candidates, target, 0, 0);
return res;
}
public void backtracking(int[] candidates, int target, int sum, int idx) {
// 找到了数字和为 target 的组合
if (sum == target) {
res.add(new ArrayList<>(path));
return;
}
for (int i = idx; i < candidates.length; i++) {
// 如果 sum + candidates[i] > target 就终止遍历
if (sum + candidates[i] > target) break;
path.add(candidates[i]);
backtracking(candidates, target, sum + candidates[i], i);
path.remove(path.size() - 1); // 回溯，移除路径 path 最后一个元素
}
}
}
4.作者链接
代码随想录
Solution40
1.问题描述
2.完整代码
class Solution {
List<List<Integer>> lists = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
boolean[] used;
int sum = 0;
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
used = new boolean[candidates.length];
backTracking(candidates, target, 0);
return lists;
}
public void backTracking(int[] arr, int target, int startIndex) {
if (sum == target) {
lists.add(new ArrayList(path));
return;
}
for (int i = startIndex; i < arr.length && arr[i] + sum <= target; i++) {
//出现重复节点，同层的第一个节点已经被访问过，所以直接跳过
if (i > 0 && arr[i] == arr[i - 1] && !used[i - 1]) {
continue;
}
used[i] = true;
sum += arr[i];
path.add(arr[i]);
//每个节点仅能选择一次，所以从下一位开始
backTracking(arr, target, i + 1);
int temp = path.removeLast();
used[i] = false;
sum -= temp;
}
}
}
905
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
