leecode77 组合问题
🔎1.回溯算法是什么？
其实回溯算法和我们常说的 DFS 算法非常类似，本质上就是一种暴力穷举算法。回溯算法和 DFS 算法的细微差别是：回溯算法是在遍历「树枝」，DFS 算法是在遍历「节点」。
解决回溯问题，其实就是在遍历一棵决策树，站在回溯树的节点上，只需考虑以下三个问题：
🔵路径：也就是已经做出的选择
🔵选择列表：即就是当前可以做的选择
🔵结束条件：也就是到达决策树底层，无法再做选择
🔎2.回溯算法解决的问题：
回溯法，一般可以解决如下几种问题：
🔵组合问题：N个数里面按一定规则找出k个数的集合
🔵切割问题：一个字符串按一定规则有几种切割方式
🔵子集问题：一个N个数的集合里有多少符合条件的子集
🔵排列问题：N个数按一定规则全排列，有几种排列方式
🔵棋盘问题：N皇后，解数独等等
🔎3.回溯算法步骤
回溯算法中函数的返回值一般为void
(1)回溯函数终止条件
既然是树形结构，一般来说搜索到叶子节点，也就找到了一条满足条件的答案
回溯终止条件的伪代码如下：
if (终止条件) {
存放结果;
return;
}
（2）回溯的遍历过程
回溯函数遍历过程伪代码如下：
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
可以从图中看出for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。
🔎4.回溯算法的模板代码框架
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
🔎代码如下：
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();
}
}
}
举例：
假设给定 n = 4，k = 2，即从 [1, 2, 3, 4] 这个集合中选取 2 个元素进行组合。
1.首先，我们初始化 result 和 path：
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
2.开始调用 combine 方法：
combine(4, 2);
进入 combineHelper 方法，初始状态下 startIndex 为 1。
第一次递归调用：
combineHelper(4, 2, 1);
因为 path 的大小还不等于 2，我们进入循环 for (int i = startIndex; i <= n - (k - path.size()) + 1; i++)，在此例中为 for (int i = 1; i <= 3; i++)。
第一次迭代，i = 1，我们将 1 添加到 path 中：
path.add(1); // path = [1]
然后进行递归调用：
combineHelper(4, 2, 2);
进入递归后，再次判断 path 的大小是否等于 2。此时还不满足，继续进行循环。由于 i 的范围是从 startIndex 开始，因此 i 的取值为 2 和 3。
第二次迭代，i = 2，我们将 2 添加到 path 中：
path.add(2); // path = [1, 2]
再次进行递归调用：
combineHelper(4, 2, 3);
进入递归后，判断 path 的大小是否等于 2，此时满足条件，我们将 path 的内容添加到 result 中：
result.add(new ArrayList<>(path)); // result = [[1, 2]]
然后返回上一层递归调用，执行 path.removeLast()，将最后一个元素从 path 中移除：
path.removeLast(); // path = [1]
回到第一次迭代，继续循环，此时 i = 3：
path.add(3); // path = [1, 3]
再次进行递归调用：
combineHelper(4, 2, 4);
进入递归后，判断 path 的大小是否等于 2，此时满足条件，将 path 的内容添加到 result 中：
result.add(new ArrayList<>(path)); // result = [[1, 2], [1, 3]]
返回上一层递归调用，执行 path.removeLast()：
path.removeLast(); // path = [1]
回到初始调用的位置，进行下一次迭代，此时 startIndex 为 2：
combineHelper(4, 2, 3);
进入递归后，判断 path 的大小是否等于 2，此时不满足条件，继续进行循环。循环只有一次，i = 3，我们将 3 添加到 path 中：
path.add(3); // path = [1, 3]
再次进行递归调用：
combineHelper(4, 2, 4);
进入递归后，判断 path 的大小是否等于 2，此时满足条件，将 path 的内容添加到 result 中：
result.add(new ArrayList<>(path)); // result = [[1, 2], [1, 3], [1, 4]]
返回上一层递归调用，执行 path.removeLast()：
path.removeLast(); // path = [1]
回到初始调用的位置，进行下一次迭代，此时 startIndex 为 3。因为 startIndex 大于 n - (k - path.size()) + 1，不满足循环条件，第一次递归调用结束。
返回到 combine 方法，此时 result 中存储了所有的组合结果。
最终返回 result：
return result; // [[1, 2], [1, 3], [1, 4]]
重复上述步骤
