LeetCodehot 力扣热题100 子集

思路解析

这个代码的目的是求一个给定整数数组 nums 的所有子集。通过 回溯（backtracking） 方法，我们可以高效地生成所有的子集。

关键思路：

1. 回溯：通过递归地遍历每个元素，决定是否将其包含在当前子集中。

2. 递归：从每个位置开始，尝试将当前数字包含或不包含，递归探索所有可能的子集。

3. 回溯恢复：在递归结束后，通过回溯将路径恢复到上一状态，以便探索其他可能的子集。

代码解析

class Solution {

public:

    vector<vector<int>> ans;  // 用于存储所有子集的结果

    vector<vector<int>> subsets(vector<int>& nums) {

        vector<int> path;  // 存储当前的子集

        back(nums, path, 0);  // 从索引 0 开始进行回溯

        return ans;  // 返回所有子集

    }



    // 回溯函数

    void back(vector<int>& nums, vector<int>& path, int n) {

        ans.push_back(path);  // 将当前路径加入结果集，路径表示一个子集

        for (int i = n; i < nums.size(); i++) {  // 从索引 n 开始遍历

            path.push_back(nums[i]);  // 将当前元素加入路径

            back(nums, path, i + 1);  // 递归调用，选择下一个元素

            path.pop_back();  // 回溯，移除当前元素，恢复路径

        }

    }

};

详细注释

1. 成员变量：

vector<vector<int>> ans;  // 用于存储所有子集的结果

• ans 用来存储所有的子集。

• 每次递归过程中，我们都会将当前的路径 path 加入 ans 中。

2. 主函数：subsets

vector<vector<int>> subsets(vector<int>& nums) {

    vector<int> path;  // 存储当前的子集

    back(nums, path, 0);  // 从索引 0 开始进行回溯

    return ans;  // 返回所有子集

}

• 输入：nums 数组（包含整数）。

• 输出：返回一个包含所有子集的二维数组 ans。

path 是一个临时数组，用来存储当前的子集。通过调用 back(nums, path, 0)，从数组的第一个元素开始递归生成所有的子集。

3. 回溯函数：back

void back(vector<int>& nums, vector<int>& path, int n) {

    ans.push_back(path);  // 将当前路径（子集）加入结果集

    for (int i = n; i < nums.size(); i++) {  // 遍历 nums 数组，从索引 n 开始

        path.push_back(nums[i]);  // 将当前元素加入路径（子集）

        back(nums, path, i + 1);  // 递归调用，选择下一个元素

        path.pop_back();  // 回溯，移除当前元素，恢复路径

    }

}

• back 是递归生成子集的核心函数。

• path 用来存储当前的子集。

• n 是当前的起始索引，确保不重复使用同一个元素。

• 每次递归时，当前的路径 path 都会加入到 ans 中，这样可以保存每次递归产生的子集。

• 在遍历数组时，对于每个元素，选择将其包含在子集中（path.push_back(nums[i])），然后递归调用 back 继续处理下一个元素。

• 回溯：在递归调用之后，我们会通过 path.pop_back() 回溯到上一个状态，去掉当前元素，探索下一种选择。

详细回溯步骤和执行过程

我们通过示例 nums = [1, 2, 3] 来详细说明回溯过程的每个步骤。

初始情况

• nums = [1, 2, 3]

• ans = []（存储结果）

• path = []（当前子集）

递归执行过程

1. 第一次递归：n = 0，path = []（空子集）

• 将当前子集 path = [] 加入到结果集 ans：

• ans = [[]]

• 从 n = 0 开始遍历 nums，即从 i = 0 开始。

2. 第一次循环：i = 0：

• 选择 nums[0] = 1，将 1 加入路径 path：

• path = [1]

• 递归调用 back(nums, path, 1)，进入下一层。

3. 第二次递归：n = 1，path = [1]

• 将当前子集 path = [1] 加入到结果集 ans：

• ans = [[], [1]]

• 从 n = 1 开始遍历 nums，即从 i = 1 开始。

4. 第二次循环：i = 1：

• 选择 nums[1] = 2，将 2 加入路径 path：

• path = [1, 2]

• 递归调用 back(nums, path, 2)，进入下一层。

5. 第三次递归：n = 2，path = [1, 2]

• 将当前子集 path = [1, 2] 加入到结果集 ans：

• ans = [[], [1], [1, 2]]

• 从 n = 2 开始遍历 nums，即从 i = 2 开始。

6. 第三次循环：i = 2：

• 选择 nums[2] = 3，将 3 加入路径 path：

• path = [1, 2, 3]

• 递归调用 back(nums, path, 3)，进入下一层。

7. 第四次递归：n = 3，path = [1, 2, 3]

• 将当前子集 path = [1, 2, 3] 加入到结果集 ans：

• ans = [[], [1], [1, 2], [1, 2, 3]]

• 此时，n == nums.size()，递归结束，返回上一层。

回溯过程（开始恢复到上一级）

• 回到 第三次递归，恢复到 path = [1, 2]，移除 3（path.pop_back()）：

• path = [1, 2]

• 返回到 第二次递归，继续遍历 i = 2。

8. 第二次递归（恢复到 path = [1, 2]）：

• 恢复状态，继续回溯，恢复到上一层的状态 path = [1]，然后继续遍历 i = 1。

9. 第二次回溯后：继续遍历 i = 2：

• 选择 nums[2] = 3，将 3 加入路径 path：

• path = [1, 3]

• 递归调用 back(nums, path, 3)，进入下一层。

10. 第五次递归：n = 3，path = [1, 3]

• 将当前子集 path = [1, 3] 加入到结果集 ans：

• ans = [[], [1], [1, 2], [1, 2, 3], [1, 3]]

• 此时，n == nums.size()，递归结束，返回上一层。

回溯过程

• 回到 第二次递归，恢复到 path = [1]，移除 3（path.pop_back()）：

• path = [1]

• 返回到 第一次递归，继续遍历 i = 1。

11. 第一次递归（恢复到 path = []）：

• 恢复状态，继续回溯，恢复到最初的 path = []，然后继续遍历 i = 1。

12. 继续遍历 i = 1：

• 选择 nums[1] = 2，将 2 加入路径 path：

• path = [2]

• 递归调用 back(nums, path, 2)，进入下一层。

13. 第六次递归：n = 2，path = [2]

• 将当前子集 path = [2] 加入到结果集 ans：

• ans = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2]]

• 从 n = 2 开始遍历 nums，即从 i = 2 开始。

14. 遍历 i = 2：

• 选择 nums[2] = 3，将 3 加入路径 path：

• path = [2, 3]

• 递归调用 back(nums, path, 3)，进入下一层。

14. 第七次递归：n = 3，path = [2, 3]

• 将当前子集 path = [2, 3] 加入到结果集 ans：

• ans = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3]]

• 此时，n == nums.size()，递归结束，返回上一层。

回溯过程

• 回到 第六次递归，恢复到 path = [2]，移除 3（path.pop_back()）：

• path = [2]

• 返回到 第一次递归，继续遍历 i = 2。

15. 第一次递归（恢复到 path = []）：

• 恢复状态，继续回溯，恢复到最初的 path = []，然后继续遍历 i = 2。

16. 遍历 i = 2：

• 选择 nums[2] = 3，将 3 加入路径 path：

• path = [3]

• 递归调用 back(nums, path, 3)，进入下一层。

17. 第八次递归：n = 3，path = [3]

• 将当前子集 path = [3] 加入到结果集 ans：

• ans = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]

• 此时，n == nums.size()，递归结束，返回上一层。

回溯过程

• 回到 第一次递归，恢复到 path = []，所有递归结束。

最终结果

• 所有的子集已经生成，最终的 ans 为：

ans = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]

关键点

• 回溯 的核心是通过 path.push_back(nums[i]) 将元素添加到路径，并通过 path.pop_back() 恢复路径，确保能够探索所有的组合。

• 每次递归时，我们保存当前路径 path 到 ans，在递归结束后回溯到之前的状态，继续尝试其他选择。

时间复杂度

• 递归深度：最多递归 n 层，其中 n 是数组的大小。

• 每次递归：每次递归我们都需要在路径中选择是否包括某个元素，因此每一层递归有两种选择，导致总的递归次数是 O(2^n)。

• 每次递归做的操作：每次递归的操作是将路径加入结果集 ans，这是 `