leecode77——组合（回溯算法）

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]]

重复上述步骤