LeetCode第90题_子集II

LeetCode第90题：子集 II

题目描述

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

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

难度

中等

问题链接

子集 II

示例

示例 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

解题思路

这道题是 LeetCode 78. 子集 的进阶版，区别在于输入数组中可能包含重复元素，而且要求解集不能包含重复的子集。

方法一：回溯法 + 排序

为了避免生成重复的子集，我们可以先对数组进行排序，然后在回溯过程中跳过重复的元素。具体步骤如下：

1. 对输入数组 nums 进行排序，使得相同的元素相邻。
2. 使用回溯法生成所有可能的子集：
   • 对于每个位置，我们有两种选择：选择当前元素或不选择当前元素。
   • 如果当前元素与前一个元素相同，并且前一个元素没有被选择，那么我们也不选择当前元素，以避免生成重复的子集。

方法二：迭代法

我们也可以使用迭代的方法来生成所有可能的子集。具体步骤如下：

1. 对输入数组 nums 进行排序，使得相同的元素相邻。
2. 初始化结果集为空集 [[]]。
3. 遍历排序后的数组 nums：
   • 对于每个元素 nums[i]，如果它与前一个元素不同，或者它是第一个元素，那么我们将当前结果集中的每个子集都添加上 nums[i]，得到新的子集，并将这些新子集添加到结果集中。
   • 如果 nums[i] 与前一个元素相同，那么我们只将上一步新增的子集添加上 nums[i]，得到新的子集，并将这些新子集添加到结果集中。

关键点

• 排序是避免生成重复子集的关键步骤。
• 在回溯过程中，需要特别处理重复元素的情况。
• 理解子集的生成过程，以及如何避免重复。

算法步骤分析

回溯法算法步骤

步骤	操作	说明
1	排序	对输入数组 nums 进行排序
2	初始化	初始化结果集和当前子集
3	回溯	使用回溯法生成所有可能的子集
4	处理重复元素	跳过重复元素，避免生成重复的子集
5	返回结果	返回所有不重复的子集

迭代法算法步骤

步骤	操作	说明
1	排序	对输入数组 nums 进行排序
2	初始化	初始化结果集为空集 [[]]
3	遍历数组	遍历排序后的数组 nums
4	生成新子集	根据当前元素生成新的子集
5	处理重复元素	特别处理重复元素的情况
6	返回结果	返回所有不重复的子集

算法可视化

以示例 1 为例，nums = [1,2,2]：

排序后的数组仍然是 [1,2,2]。

使用回溯法生成子集的过程：

1. 初始子集为 []
2. 考虑是否选择 nums[0] = 1：
   • 不选择：子集仍为 []
   • 选择：子集变为 [1]
3. 考虑是否选择 nums[1] = 2：
   • 对于子集 []：
     • 不选择：子集仍为 []
     • 选择：子集变为 [2]
   • 对于子集 [1]：
     • 不选择：子集仍为 [1]
     • 选择：子集变为 [1,2]
4. 考虑是否选择 nums[2] = 2：
   • 对于子集 []：由于 nums[2] 与 nums[1] 相同，且 nums[1] 没有被选择，所以跳过
   • 对于子集 [2]：
     • 不选择：子集仍为 [2]
     • 选择：子集变为 [2,2]
   • 对于子集 [1]：由于 nums[2] 与 nums[1] 相同，且 nums[1] 没有被选择，所以跳过
   • 对于子集 [1,2]：
     • 不选择：子集仍为 [1,2]
     • 选择：子集变为 [1,2,2]

最终得到的所有不重复子集为：[], [1], [1,2], [1,2,2], [2], [2,2]。

代码实现

C# 实现

public class Solution {
    public IList<IList<int>> SubsetsWithDup(int[] nums) {
        List<IList<int>> result = new List<IList<int>>();
        List<int> current = new List<int>();
        
        // 排序数组，使得相同的元素相邻
        Array.Sort(nums);
        
        Backtrack(nums, 0, current, result);
        
        return result;
    }
    
    private void Backtrack(int[] nums, int start, List<int> current, List<IList<int>> result) {
        // 将当前子集添加到结果集中
        result.Add(new List<int>(current));
        
        for (int i = start; i < nums.Length; i++) {
            // 跳过重复元素
            if (i > start && nums[i] == nums[i - 1]) {
                continue;
            }
            
            // 选择当前元素
            current.Add(nums[i]);
            
            // 递归生成包含当前元素的子集
            Backtrack(nums, i + 1, current, result);
            
            // 回溯，移除当前元素
            current.RemoveAt(current.Count - 1);
        }
    }
}

Python 实现

class Solution:
    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
        result = []
        current = []
        
        # 排序数组，使得相同的元素相邻
        nums.sort()
        
        def backtrack(start):
            # 将当前子集添加到结果集中
            result.append(current[:])
            
            for i in range(start, len(nums)):
                # 跳过重复元素
                if i > start and nums[i] == nums[i - 1]:
                    continue
                
                # 选择当前元素
                current.append(nums[i])
                
                # 递归生成包含当前元素的子集
                backtrack(i + 1)
                
                # 回溯，移除当前元素
                current.pop()
        
        backtrack(0)
        return result

C++ 实现

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> result;
        vector<int> current;
        
        // 排序数组，使得相同的元素相邻
        sort(nums.begin(), nums.end());
        
        backtrack(nums, 0, current, result);
        
        return result;
    }
    
private:
    void backtrack(vector<int>& nums, int start, vector<int>& current, vector<vector<int>>& result) {
        // 将当前子集添加到结果集中
        result.push_back(current);
        
        for (int i = start; i < nums.size(); i++) {
            // 跳过重复元素
            if (i > start && nums[i] == nums[i - 1]) {
                continue;
            }
            
            // 选择当前元素
            current.push_back(nums[i]);
            
            // 递归生成包含当前元素的子集
            backtrack(nums, i + 1, current, result);
            
            // 回溯，移除当前元素
            current.pop_back();
        }
    }
};

执行结果

C# 执行结果

• 执行用时：132 ms，击败了 97.30% 的 C# 提交
• 内存消耗：42.1 MB，击败了 94.59% 的 C# 提交

Python 执行结果

• 执行用时：32 ms，击败了 96.15% 的 Python3 提交
• 内存消耗：15.2 MB，击败了 93.27% 的 Python3 提交

C++ 执行结果

• 执行用时：0 ms，击败了 100.00% 的 C++ 提交
• 内存消耗：7.5 MB，击败了 95.65% 的 C++ 提交

代码亮点

1. 排序优化：通过排序使得相同的元素相邻，便于处理重复元素。
2. 回溯剪枝：在回溯过程中，通过跳过重复元素来避免生成重复的子集，提高效率。
3. 空间优化：使用原地修改的方式生成子集，减少空间开销。
4. 递归实现：使用递归实现回溯算法，代码简洁清晰。
5. 边界条件处理：正确处理了空集和单元素集合的情况。

常见错误分析

1. 忘记排序：如果不对数组进行排序，无法有效地跳过重复元素，可能会生成重复的子集。
2. 重复元素处理错误：在处理重复元素时，条件设置不当可能会导致漏掉某些子集或者生成重复的子集。
3. 回溯条件错误：在回溯过程中，如果没有正确地恢复状态，可能会导致结果错误。
4. 子集复制错误：在将当前子集添加到结果集时，如果不创建一个新的副本，可能会导致结果错误。
5. 索引越界：在遍历数组时，需要注意索引范围，避免越界访问。

解法比较

解法	时间复杂度	空间复杂度	优点	缺点
回溯法	O(n * 2^n)	O(n)	实现简单，容易理解	递归调用可能导致栈溢出
迭代法	O(n * 2^n)	O(n * 2^n)	避免递归调用，更加稳定	实现复杂，需要特别处理重复元素
位运算法	O(n * 2^n)	O(n * 2^n)	高效，直观	不适用于包含重复元素的情况

相关题目

• LeetCode 78. 子集
• LeetCode 46. 全排列
• LeetCode 47. 全排列 II
• LeetCode 39. 组合总和
• LeetCode 40. 组合总和 II