代码随想录第24天 | 回溯算法 之 77. 组合

前言：

1、回溯和递归相辅相成， 回溯隐藏在递归算法里面  

2、回溯法是一种暴力解法，有的题只能用回溯法来解。那哪些题需要用回溯法来解呢？如下：

3、回溯法解决的问题都可以抽象为树形结构 

 77. 组合

77. 组合 - 力扣（LeetCode）

代码随想录 (programmercarl.com)

带你学透回溯算法-组合问题（对应力扣题目：77.组合）| 回溯法精讲！_哔哩哔哩_bilibili

给定两个整数 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

这个题一开始没什么思路，直接看题解了。

把组合问题抽象为以下树形结构：

 一开始这个集合是：1、2、3、4，从左向右取数，取过的数不再重复取。这样每次从集合中选取元素，可选择的范围就会随着取出值之后变小，从而调整可以选择的范围。

n相当于树的宽度，k相当于树的深度。收集叶子节点即为最终结果。

回溯三部曲：

1、递归函数的返回值以及参数：定义2个全局变量，一个用来放符合条件的单一结果，一个用来放符合条件结果的集合：

class Solution{
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();    

}

为什么这里一个定义为数组，一个定义为链表呢？

1. result 存储最终的组合结果。由于在算法的执行过程中需要频繁进行增加操作（即向列表末尾添加元素），而 ArrayList 在尾部添加元素的效率较高，因此选择了 ArrayList。此外，由于最终需要访问整个组合结果，而 ArrayList 支持随机访问，因此也适合存储最终结果。

2. path 用于暂存当前的组合路径。在算法的执行过程中，需要频繁进行插入和删除操作（即在路径末尾添加元素并在需要时删除末尾元素），而 LinkedList 在任意位置的插入和删除操作的效率较高，因此选择了 LinkedList。此外，由于在回溯算法中，需要不断地在路径末尾添加元素和删除末尾元素，而 LinkedList 的特性正好符合这种需求，因此也更适合用于存储当前组合路径。

已知题目中给了n和k这两个参数，数据类型为int。还需要一个参数来记录本层递归中，集合是从哪里开始遍历的，设置这个参数为startIndex,startIndex的作用就是防止出现重复的组合。

从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex。

所以参数值如下：

private void combineHelper(int n, int k, int startIndex) {
   
}

 2、确定终止条件：到达叶子节点的时候终止。什么时候到达叶子节点呢？path数组大小等于k的时候到达叶子节点：

// 终止条件：当当前组合路径的长度等于k时，将当前路径加入结果集，并返回

if(path.size() == k) {
    result.add(new ArrayList<>(path));
    return;
}

 3、确定单层回溯的逻辑：

for (int i = startIndex; i <= n; i++) {
    // 将当前数字i加入组合路径中
    path.add(i);
    // 递归调用backtracking方法，寻找下一个数字的组合，startIndex为i+1，确保组合中的数字不重复
    backtracking(n, k, i + 1);
    // 回溯，将刚加入的数字i移除，继续寻找其他可能的组合
    path.removeLast();
}

 综合代码（剪枝前）：

// 定义Solution类
class Solution {
    // 声明一个成员变量result，用于存储最终的组合结果，初始化为一个空的ArrayList
    List<List<Integer>> result = new ArrayList<>();
    // 声明一个成员变量path，用于暂存当前的组合路径，初始化为一个空的LinkedList
    LinkedList<Integer> path = new LinkedList<>();
    
    // 定义combine方法，接收整数n和k作为参数，返回符合条件的组合结果
    public List<List<Integer>> combine(int n, int k) {
        // 调用backtracking方法，开始回溯求解组合
        backtracking(n, k, 1);
        // 返回最终的组合结果
        return result;
    }

    // 定义backtracking方法，用于回溯求解组合
    public void backtracking(int n, int k, int startIndex) {
        // 当当前组合路径的长度等于k时，将当前路径加入结果集，并返回
        if (path.size() == k) {
            result.add(new ArrayList<>(path));
            return;
        }
        // 循环遍历从startIndex到n的数字
        for (int i = startIndex; i <= n; i++) {
            // 将当前数字i加入组合路径中
            path.add(i);
            // 递归调用backtracking方法，寻找下一个数字的组合，startIndex为i+1，确保组合中的数字不重复
            backtracking(n, k, i + 1);
            // 回溯，将刚加入的数字i移除，继续寻找其他可能的组合
            path.removeLast();
        }
    }
}

回溯算法模板代码：

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

剪枝优化：

在本题中，有一条路径是不用遍历的：

可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

优化部分：

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
            // 将当前数字i加入组合路径中
            path.add(i);
            // 递归调用combineHelper方法，寻找下一个数字的组合，startIndex为i+1，确保组合中的数字不重复
            combineHelper(n, k, i + 1);
            // 回溯，将刚加入的数字i移除，继续寻找其他可能的组合
            path.removeLast();
        }

优化后的综合代码：

// 定义Solution类
class Solution {
    // 声明一个成员变量result，用于存储最终的组合结果，初始化为一个空的ArrayList
    List<List<Integer>> result = new ArrayList<>();
    // 声明一个成员变量path，用于暂存当前的组合路径，初始化为一个空的LinkedList
    LinkedList<Integer> path = new LinkedList<>();
    
    // 定义combine方法，接收整数n和k作为参数，返回符合条件的组合结果
    public List<List<Integer>> combine(int n, int k) {
        // 调用combineHelper方法，开始组合求解
        combineHelper(n, k, 1);
        // 返回最终的组合结果
        return result;
    }

    /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    // 定义combineHelper方法，用于递归求解组合
    private void combineHelper(int n, int k, int startIndex) {
        // 终止条件：当当前组合路径的长度等于k时，将当前路径加入结果集，并返回
        if (path.size() == k) {
            result.add(new ArrayList<>(path));
            return;
        }
        // 循环遍历从startIndex到n的数字，确保组合中的数字不重复
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
            // 将当前数字i加入组合路径中
            path.add(i);
            // 递归调用combineHelper方法，寻找下一个数字的组合，startIndex为i+1，确保组合中的数字不重复
            combineHelper(n, k, i + 1);
            // 回溯，将刚加入的数字i移除，继续寻找其他可能的组合
            path.removeLast();
        }
    }
}

后续总结：优化部分还需要强化，有点懵。