90.子集II- 力扣(LeetCode)

最新推荐文章于 2025-08-16 00:47:01 发布

原创最新推荐文章于 2025-08-16 00:47:01 发布 · 450 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #python

题目：

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

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

示例 1：

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

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

示例 2：

输入：nums = [0]

输出：[[],[0]]

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10

思路如下：

解法一:使用Python的库函数itertools.combinations(iterable, r)，详情见78题，该题与78题的区别是输入可以有重复元素，但是输出的子集不可以有重复元素，所以在向结果列表中添加时，需要判断结果列表中没有该元素。

解法二：在78题迭代基础上，将所有子集结果转化为元组作为字典的键，去掉重元素后再转换为列表。或者提前预防，通过排序预处理和动态控制子集扩展范围，直接在生成子集时避免重复，无需后处理。

解法三：在78题回溯基础上，加上限制条件。

题解如下：

解法一：

class Solution:
    def subsetsWithDup(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):
                if tmp not in res:
                    res.append(tmp)
        return res

解法二：

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

        dit = {}
        unique_subsets = []
        for subset in res:
            # 将子集转为元组作为字典的键
            tuple_subset = tuple(subset)
            if tuple_subset not in dit:
                dit[tuple_subset] = True
                unique_subsets.append(list(tuple_subset))
        return unique_subsets  # 返回所有子集
#2.2
class Solution:
    def subsetsWithDup(self, nums):
        """
                        :type:    nums: List[int]
                        :rtype:   List[List[int]]
        """
        if not nums: 
            return []          # 空数组直接返回空列表
        nums.sort()           # 关键步骤1：排序使重复元素相邻
        res = [[]]            # 初始化结果列表，包含空子集
        cur = []              # 记录当前轮生成的新子集
        
        for i in range(len(nums)):  # 遍历每个元素的索引
            if i > 0 and nums[i-1] == nums[i]:
                # 重复元素：仅将当前元素添加到上一轮生成的新子集（cur）中
                cur = [tmp + [nums[i]] for tmp in cur]
            else:
                # 新元素：将当前元素添加到所有现有子集（res）中
                cur = [tmp + [nums[i]] for tmp in res]
            
            res += cur       # 将新生成的子集加入结果列表
        
        return res

解法三：

class Solution:
    def subsetsWithDup(self, nums):
        """
                        :type:    nums: List[int]
                        :rtype:   List[List[int]]
        """
        res = []
        n = len(nums)
        nums.sort()
        def helper(idx, tmp):
            res.append(tmp)
            for i in range(idx, n):
                if i > idx and nums[i] == nums[i-1]:
                    continue
                helper(i+1, tmp + [nums[i]])
        helper(0, [])
        return res