78.子集- 力扣(LeetCode)

题目：

        给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

        解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]

输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]

输出：[[],[0]]

提示：

• 1 <= nums.length <= 10

• -10 <= nums[i] <= 10

• nums 中的所有元素 互不相同

思路如下：

解法一：使用Python的库函数itertools.combinations(iterable, r)，详情见77题。与77题的差别是输出结果包含长度k范围为[0 ,n ]的结果。

解法二：通过迭代逐步构建子集，每次将当前元素与之前的所有子集组合，生成新的子集。在初始化结果列表，要包含空子集。

解法三：回溯算法，通过逐步选择元素并递归处理后续位置，确保生成的子集唯一且按原数组顺序排列。

题解如下：

解法一：Python的库函数

class Solution:
    def subsets(self, nums):
        """
                        :type:    nums: List[int]
                        :rtype:   List[List[int]]
        """
        res = []
        for i in range(len(nums)+1):
            for tmp in itertools.combinations(nums, i):
                res.append(tmp)
        return res

解法二：迭代

class Solution:
    def subsets(self, nums):
        """
                        :type:    nums: List[int]
                        :rtype:   List[List[int]]
        """
        res = [[]]  # 初始化结果列表，包含空子集
        for i in nums:  # 遍历 nums 中的每个元素
            res = res + [num + [i] for num in res]  # 将当前元素与已有子集组合，生成新子集
        return res  # 返回所有子集

解法三：回溯算法

class Solution:
    def subsets(self, nums):
        """
                        :type:    nums: List[int]
                        :rtype:   List[List[int]]
        """
        res = []        # 存储所有子集的列表
        n = len(nums)   # 输入数组的长度
        
        def helper(i, tmp):
            res.append(tmp)             # 将当前子集加入结果
            for j in range(i, n):       # 从当前位置i开始遍历后续元素
                helper(j + 1, tmp + [nums[j]])  # 递归生成包含nums[j]的子集
        
        helper(0, [])    # 从第0个元素开始，初始子集为空
        return res       # 返回所有子集

代码逻辑：

解法一：

把77题长度k范围为[0 ,n ]的结果均加入结果列表。

解法二：

1.初始化： res 初始化为 [[]]，表示仅包含空子集。

2.迭代构建子集： 遍历 nums 中的每个元素 i，每次将 i 添加到 res 中所有已有子集的开头，生成新的子集，并与原 res 合并。

3.动态扩展：

例如，若 nums = [1, 2, 3]，迭代过程如下：

• 初始：res = [[]]

• 处理 1：生成 [[1]] → 合并后 res = [[], [1]]

• 处理 2：生成 [[2], [1, 2]] → 合并后 res = [[], [1], [2], [1, 2]]

• 处理 3：生成 [[3], [1, 3], [2, 3], [1, 2, 3]]→ 合并后得到所有子集。

解法三：

1.初始化：

• res 初始化为空列表，用于收集所有子集。

• n 记录输入数组的长度。

2.递归函数 helper：

参数：

• i：当前可选的起始位置。

• tmp：当前正在构建的子集。

终止条件：隐含在循环中，当 j 遍历完所有元素后递归结束。

递归过程：

• 将当前子集 tmp 加入结果列表 res。

• 从位置 i 开始遍历后续元素，依次将 nums[j] 加入 tmp，并递归调用 helper(j+1, tmp + [nums[j]])。

3.递归调用链：

• 初始调用 helper(0, []) 从空子集开始。

• 每次递归选择当前元素 nums[j]，并通过 j+1 确保下一层递归只能选后续元素，避免重复。

4.示例推导：

4.1初始调用：helper(0, [])

• res 添加 []。

• 遍历 j=0（元素1），递归调用 helper(1, [1])。

4.2递归调用 helper(1, [1])：

• res 添加 [1]。

• 遍历 j=1（元素2），递归调用 helper(2, [1, 2])。

4.3递归调用 helper(2, [1, 2])：

• res 添加 [1, 2]。

• 遍历 j=2（元素3），递归调用 helper(3, [1, 2, 3])。

4.4递归调用 helper(3, [1, 2, 3])：

• res 添加 [1, 2, 3]。

• j 从3开始，超出数组范围，循环结束。

4.5回溯处理其他分支：

• 回到 helper(1, [1])，处理 j=2（元素3），调用 helper(3, [1, 3])，添加 [1, 3]。

• 回到 helper(0, [])，处理 j=1（元素2），调用 helper(2, [2])，添加 [2]，再处理 j=2（元素3），调用 helper(3, [2, 3])，添加 [2, 3]。

• 回到 helper(0, [])，处理 j=2（元素3），调用 helper(3, [3])，添加 [3]。

最终结果： [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]