LeetCode 90. 子集 II

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

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

示例 1：

ini 复制代码

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

示例 2：

lua 复制代码

输入： nums = [0]
输出： [[],[0]]

提示：

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

方法一：迭代法实现子集枚举

思路

考虑数组 $1,2,2$ ，选择前两个数，或者第一、三个数，都会得到相同的子集。

也就是说，对于当前选择的数 x，若前面有与其相同的数 y，且没有选择 y，此时包含 x 的子集，必然会出现在包含 y 的所有子集中。

我们可以通过判断这种情况，来避免生成重复的子集。

代码实现时，可以先将数组排序；迭代时，若发现没有选择上一个数，且当前数字与上一个数相同，则可以跳过当前生成的子集。

kotlin 复制代码

class Solution {
    fun subsetsWithDup(nums: IntArray): List<List<Int>> {
        // 首先对数组进行排序
        nums.sort()
        val result = mutableListOf<List<Int>>()
        val n = nums.size

        for (i in 2f.pow(n).toInt()..<2f.pow(n + 1).toInt()) {
//            生成 01 字符串，以 [1,2,3] 为例
//            bitmask = 000
//            bitmask = 001
//            bitmask = 010
//            bitmask = 011
//            bitmask = 100
//            bitmask = 101
//            bitmask = 110
//            bitmask = 111
            val bitmask = Integer.toBinaryString(i).substring(1)
            val subset = mutableListOf<Int>()
            var flag = true
            for (j in 0..<n) {
                // 对于 nums 中的每个数，如果字符串中该数位为1则加入子集，反之则跳过
                if (bitmask[j] == '1') {
                    // 如果发现没有选择上一个数，且当前数字与上一个数相同，则可以跳过当前生成的子集
                    if (j > 0 && nums[j - 1] == nums[j] && bitmask[j - 1] == '0') {
                        flag = false
                        break
                    }
                    subset.add(nums[j])
                }
            }
            if (flag) {
                result.add(subset)
            }
        }
        return result
    }
}

复杂度分析

时间复杂度：O(n×2 n )，其中 n 是数组 nums 的长度。排序的时间复杂度为 O(nlogn)。一共 2 n 个状态，每种状态需要 O(n) 的时间来构造子集，一共需要 O(n×2 n ) 的时间来构造子集。由于在渐进意义上 O(nlogn) 小于 O(n×2 n )，故总的时间复杂度为 O(n×2 n )。

空间复杂度：O(n)。即构造子集使用的临时数组 t 的空间代价。

方法二：递归法实现子集枚举

思路

与方法一类似，在递归时，若发现没有选择上一个数，且当前数字与上一个数相同，则可以跳过当前生成的子集。

kotlin 复制代码

class Solution2 {
    val result = mutableListOf<List<Int>>()
    fun subsetsWithDup(nums: IntArray): List<List<Int>> {
        // 首先对数组进行排序
        nums.sort()
        dfs(false, 0, cur = mutableListOf(), nums = nums)
        return result
    }

    fun dfs(choosePre: Boolean, level: Int, cur: MutableList<Int>, nums: IntArray) {
        if (level == nums.size) {
            val subset = mutableListOf<Int>()
            subset.addAll(cur)
            result.add(subset)
            return
        }
        dfs(false, level + 1, cur, nums)
        if (!choosePre && level > 0 && nums[level - 1] == nums[level]) {
            return
        }
        cur.add(nums[level])
        dfs(true, level + 1, cur, nums)
        cur.removeAt(cur.size - 1)
    }
}

复杂度分析

时间复杂度：O(n×2 n )，其中 n 是数组 nums 的长度。排序的时间复杂度为 O(nlogn)。最坏情况下 nums 中无重复元素，需要枚举其所有 2 n 个子集，每个子集加入答案时需要拷贝一份，耗时 O(n)，一共需要 O(n×2 n )+O(n)=O(n×2 n ) 的时间来构造子集。由于在渐进意义上 O(nlogn) 小于 O(n×2 n )，故总的时间复杂度为 O(n×2 n )。

空间复杂度：O(n)。临时数组 t 的空间代价是 O(n)，递归时栈空间的代价为 O(n)。