leetcode 90. Subsets II (2 ways)_2ways形式指令-优快云博客

博客围绕含重复元素的整数数组求所有可能子集展开，要求结果无重复子集。介绍了两种方法，一是对应78题方法2，先对数组排序，根据元素是否重复决定添加子集的范围；二是DFS，对78题代码做改动，排序数组并在处理中跳过相同元素。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

Input: [1,2,2]
Output:
[
[2],
[1],
[1,2,2],
[2,2],
[1,2],
[]
]

和78题一样，不同的是有重复元素，而不允许有重复子集

思路：
方法1:
对应78题的方法2
首先考虑的是把数组sort，这样相同的元素会放在一起

input = [1, 2, 2]时
首先[]
然后读1：[], [1]
然后读2: [], [1], [2], [1, 2]
然后读2，注意这时候按照上一步的子集添加2的话头两个子集[], [1]添加2后变为[2], [1, 2]
会和上面一步的后两个子集重复，而仅需要在[2], [1, 2]上添加2，
[], [1], [2], [1, 2], [2, 2], [1, 2, 2]

可以看到读入第二个元素2时，因为和前一元素1不同，所以遍历所有上一步的子集
而第3个元素2读入时，因为和前一元素相同，所以不需要考虑[], [1]，而这个[], [1]子集是在添加第二个元素2之前的结果，
因此读入第3个元素2时，因为和上一个元素相同，所以不考虑上一个元素之前的部分

//0ms
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        Arrays.sort(nums);
        
        int size = 1;
        int last = nums[0];
        List<Integer> cur = new ArrayList<>();
        result.add(new ArrayList<Integer>());
        
        for (int i = 0; i < nums.length; i++) {
            if (last != nums[i]) {
                last = nums[i];
                size = result.size();
            }
            int newSize = result.size();
            //add the current element to get more subset..
            //if current element != last, then add to subset 0~size..
            //if not equal, then skip the subset before last element..
            for (int j = newSize - size; j < newSize; j++) {
                cur = result.get(j);
                List<Integer> tmp = new ArrayList<>(cur);
                tmp.add(nums[i]);
                result.add(tmp);
            }
        }
        
        return result;
    }

方法2:
DFS
78题的代码仅需作两步改动，一个是添加对数组的sort，使相同的元素放在一起
其次在DFS处理过程中，跳过相同的元素，即最后的while部分
注意条件size的判断是i + 1 < size
注意结果中包含空集，所以size要从0开始

//1ms
     public List<List<Integer>> subsetsWithDup(int[] nums) {
        if (nums == null || nums.length == 0) {
            return new ArrayList<List<Integer>>();
        }
        
        int n = nums.length;
        Arrays.sort(nums);
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>>();
        List<Integer> cur = new ArrayList<Integer>();
        
            
        for (int i = 0; i <= n; i++) {
            dfs(nums, i, 0, cur, result);
        }
        
        return result;
        
    }
    
    public void dfs(int[] nums, int len, int start, List<Integer> cur, ArrayList<List<Integer>> result) {
        if (len == cur.size()) {
            ArrayList<Integer> tmp = new ArrayList<>(cur);
            result.add(tmp);
            return;
        }
        
        for (int i = start; i < nums.length; i++) {
            cur.add(nums[i]);
            dfs(nums, len, i + 1, cur, result);
            cur.remove(cur.size() - 1);
            while (i + 1 < nums.length && nums[i] == nums[i + 1]) {
                i ++;
            }
        }
    }