力扣第77题 组合 c++ 回溯经典题 注释加优化 代码

题目

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

提示：

• 1 <= n <= 20
• 1 <= k <= n

思路和解题方法

在类 Solution 中定义了两个成员变量：

• ans：用于存储所有组合的二维数组。
• vec：用于存储当前组合的一维数组。

        接下来，有一个私有方法 backtrackint()，该方法使用递归和回溯的方式生成所有的组合。方法的参数包括 n（总范围）、k（选择数量）和 startIndex（当前选择的数字范围的起始位置）。

        在 backtrackint() 方法中，首先进行终止条件的判断。如果当前组合的大小等于 k，说明已经选取了足够数量的数字，将当前组合加入到结果数组 ans 中，并返回。

然后，使用一个循环从 startIndex 到 n 进行遍历。在每次循环中，将当前的数字加入到当前组合中（即 vec.push_back(i)），然后通过递归调用 backtrackint() 函数，在从 i+1 到 n 的范围内选择下一个数字。递归调用完成后，需要进行回溯操作，即将上一步加入的数字移出当前组合（即 vec.pop_back()），以便继续生成其他组合。

        在主函数 combine() 中，首先清空存储结果的数组 ans 和当前组合的数组 vec。然后调用 backtrackint() 方法开始生成由 1~n 中选取 k 个数字的所有组合。最后返回结果数组 ans。

        这段代码的核心思想是利用回溯算法，在搜索过程中逐步构建组合，并在选取完 k 个数字后将组合加入到结果数组中，同时进行回溯操作以继续生成其他组合。

复杂度

        时间复杂度:

                O(C(n,k))

时间复杂度是 O(C(n,k))，其中 n 表示数字范围的大小，k 表示选择的数字数量。C(n, k) 是组合数，表示从 n 个数字中选取 k 个数字的组合数量。

        空间复杂度

                O(k)

空间复杂度是 O(k)，其中 k 表示选择的数字数量。主要的空间消耗在结果数组 ans 和当前组合数组 vec 上。递归调用的深度为 k，每次递归调用都需要创建一个新的组合数组 vec，并且结果数组 ans 也会存储最终的组合结果。

c++ 代码

class Solution {
public:
    vector<vector<int>> ans; // 存储所有组合的二维数组
    vector<int> vec; // 存储当前组合的一维数组

    // 递归回溯函数，startIndex 表示当前选择的数字范围的起始位置
    void backtrackint(int n, int k, int startIndex) {
        if(vec.size() == k) { // 如果已经选了 k 个数字，将当前组合加入结果数组
            ans.push_back(vec);
            return;
        }

        for(int i = startIndex; i <= n; i++) { // 在从 startIndex 到 n 中选一个数字加入当前组合
            vec.push_back(i);
            backtrackint(n, k, i + 1); // 递归，在从 i+1 到 n 中选下一个数字
            vec.pop_back(); // 回溯，撤销上一步加入的数字
        }
    }

    vector<vector<int>> combine(int n, int k) {
        ans.clear();
        vec.clear();
        backtrackint(n, k, 1);
        return ans;
    }
};

优化 具体解释

当 path 长度达到 k 时，将 path 中的数字加入到结果数组中，并返回。

然后通过循环枚举可选数字的起始位置，遍历从 startIndex 到 (n - (k - path.size()) + 1) 的数字。这里需要解释一下 (n - (k - path.size()) + 1)，其实就是用来保证从当前数字一直取到最后一个数字，至少还剩下 k - path.size() 个数字，否则就不可能凑够 k 个数字。

在循环内部，首先将 i 加入到 path 中，然后递归调用自己，但此时的起始位置为 i+1。等到递归调用返回时，回溯撤销已经加入路径的数字，以便继续尝试其他数字。

c++优化后的代码

class Solution {
private:
    vector<vector<int>> result; // 存储所有符合条件的组合
    vector<int> path; // 当前的组合
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) { // 如果当前的组合大小已经等于 k，说明已经选取了足够数量的数字，将当前组合加入到结果数组中
            result.push_back(path); // 添加当前的组合到结果数组中
            return; // 返回
        }
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) { // 重点优化处 遍历可选的节点
            path.push_back(i); // 处理节点，将当前的数字加入到当前组合中
            backtracking(n, k, i + 1); // 递归调用，从 i+1 到 n 的范围内选择下一个数字
            path.pop_back(); // 回溯，撤销处理的节点，将上一步加入的数字移出当前组合
        }
    }
public:
    vector<vector<int>> combine(int n, int k) {
        backtracking(n, k, 1); // 从 1 开始进行回溯
        return result; // 返回所有符合条件的组合
    }
};

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。