代码随想录-Day24

77. 组合

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

方法一：递归实现组合型枚举

class Solution {
    List<Integer> temp = new ArrayList<Integer>();
    List<List<Integer>> ans = new ArrayList<List<Integer>>();

    public List<List<Integer>> combine(int n, int k) {
        dfs(1, n, k);
        return ans;
    }

    public void dfs(int cur, int n, int k) {
        // 剪枝：temp 长度加上区间 [cur, n] 的长度小于 k，不可能构造出长度为 k 的 temp
        if (temp.size() + (n - cur + 1) < k) {
            return;
        }
        // 记录合法的答案
        if (temp.size() == k) {
            ans.add(new ArrayList<Integer>(temp));
            return;
        }
        // 考虑选择当前位置
        temp.add(cur);
        dfs(cur + 1, n, k);
        temp.remove(temp.size() - 1);
        // 考虑不选择当前位置
        dfs(cur + 1, n, k);
    }
}

这段代码定义了一个名为 Solution 的类，该类包含两个成员变量和两个方法，用于解决组合问题（Combinations）。具体来说，它寻找从 1 到 n 的整数中所有可能的 k 个数的组合。例如，当 n=4, k=2 时，答案应包括 [1,2], [1,3], [1,4], [2,3], [2,4], [3,4]。

成员变量

• temp：一个 List<Integer> 类型的临时列表，用于存储当前正在构建的组合。
• ans：一个 List<List<Integer>> 类型的答案列表，用于存储所有找到的组合。

方法

combine(int n, int k)

• 功能：这是主要的接口方法，接收两个整数参数 n 和 k，返回所有可能的 k 项组合。
• 过程：首先调用深度优先搜索（DFS）方法 dfs 来生成所有组合，然后返回最终的答案列表 ans。

dfs(int cur, int n, int k)

• 功能：这是一个递归方法，用于生成所有可能的组合。
• 参数：cur 表示当前考虑的起始数字，n 是整数的上界，k 是组合中元素的数量。
• 剪枝：在递归调用前，通过检查当前已选数字数量（temp.size()）加上剩余可选数字（n - cur + 1）是否小于 k 来进行剪枝，如果小于则直接返回，避免无效的递归。
• 递归逻辑：
  • 先选择当前位置的数字，将其加入 temp，然后递归调用 dfs 函数尝试在剩余数字中选择，这里 cur+1 表示下一个要考虑的数字。
  • 在递归调用返回后，需要从 temp 中移除最后一个添加的数字（回溯），以尝试不包含当前位置数字的其他组合。
  • 接着，直接递归调用 dfs 函数跳过当前位置的数字，继续在后面的数字中寻找组合。

通过这种递归加回溯的策略，所有可能的 k 项组合都被探索并记录在 ans 中，最后由 combine 方法返回。

方法二：回溯法（未剪枝）

class Solution {
    List<List<Integer>> result= new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtracking(n,k,1);
        return result;
    }

    public void backtracking(int n,int k,int startIndex){
        if (path.size() == k){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i =startIndex;i<=n;i++){
            path.add(i);
            backtracking(n,k,i+1);
            path.removeLast();
        }
    }
}

这段代码定义了一个名为 Solution 的类，用于解决经典的组合问题，即从 1 到 n 这些整数中选择 k 个数的所有可能组合。该问题通常称为 “组合总和” 问题的一个特例，但在这里实际上是在找无重复数字的组合，不涉及总和的约束，更准确地说，是寻找组合而非排列，因为顺序不重要。下面是代码的详细解析：

类成员变量

• List<List<Integer>> result：用于存储所有满足条件的组合结果。
• LinkedList<Integer> path：用于暂存当前递归路径上的组合元素。

主方法 combine(int n, int k)

• 功能：接收两个整数参数 n 和 k，分别代表可选择的数的最大值以及需要选取的数的数量。调用 backtracking 函数来递归生成所有组合，并返回最终的组合列表 result。

辅助方法 backtracking(int n, int k, int startIndex)

• 功能：递归实现回溯算法来生成所有组合。
• 终止条件：当 path 中的元素数量达到 k 时，说明当前路径构成了一个有效的组合，将其添加到结果列表 result 中并返回。
• 单层递归逻辑：从 startIndex 开始遍历到 n（包括 n），将当前遍历到的数 i 加入到 path 中，然后基于这个选择继续深入下一层递归。递归调用结束后，通过 path.removeLast() 回溯，撤销刚才的添加操作，以便尝试下一种可能的数字。

代码特点

• 使用了回溯算法，这是一种通过试错来寻找解空间树中所有解的通用算法，非常适合解决此类组合问题。
• 通过 startIndex 参数控制下一轮递归的起始点，避免了重复选择相同的元素，确保了组合的唯一性。
• 结果是以二维列表的形式返回，每个子列表代表一组可能的组合。

整体而言，这段代码清晰地展示了如何利用回溯法解决组合问题，是此类问题的经典实现方式。

方法三：回溯法（剪枝优化）

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();
        }
    }
}

这段代码同样实现了一个求解从1到n的整数中挑选k个数的所有可能组合的问题，与之前的版本相比，主要区别在于combineHelper方法中for循环的迭代条件。以下是该版本代码的解析：

类成员变量

• List<List<Integer>> result：存储所有满足条件的组合结果。
• LinkedList<Integer> path：临时保存当前搜索路径中的元素，即当前正在构建的组合。

主方法 combine(int n, int k)

• 功能：接收两个整数参数n和k，初始化后调用combineHelper进行递归计算，最后返回所有组合结果。

辅助方法 combineHelper(int n, int k, int startIndex)

• 功能：递归实现组合生成，通过修改startIndex来控制每一步搜索的起始位置，确保不会重复选择数字。
• 终止条件：当path中元素数量达到k时，将当前组合添加到结果列表并返回。
• 迭代条件优化：for循环中的条件i <= n - (k - path.size()) + 1是关键改进。此条件确保了在当前路径已选择的元素数量基础上，剩下的可选项足以完成组合（即至少还有k - path.size()个数要选），因此从i开始遍历至最大必要数。这避免了不必要的迭代，提高了算法效率，尤其是在k较大且接近n时效果明显。

代码特点

• 通过调整startIndex控制递归搜索的边界，使得算法更加高效，减少了不必要的递归调用。
• 继续使用回溯策略，通过添加和移除path中的元素实现状态的回溯，探索所有可能的组合。
• 代码结构清晰，注释说明了startIndex的作用，便于理解。

综上所述，这个版本通过优化递归时的遍历范围，提升了在特定情况下的执行效率，保持了回溯算法的基本框架，是解决组合问题的一个高效实现。