力扣之子集系列

Leetcode 0078 子集

题目描述：Leetcode 0078 子集

分析

• 本题的考点：位运算。

• 如果nums中有n个元素，则其子集的个数为 2 n 2^n 2n个。

• 我们可以使用一个二进制数据mask中的后n位表示nums数组中的每个元素是否被选择，如果mask & (1 << i)是1的话，表示nums[i]在当前的子集中。

• 我们让mask从0循环到(1 << n) - 1就可以得到所有子集，每个不同的mask值对应一个子集。

代码

• C++

class Solution {
public:
    vector<vector<int>> subsets(vector<int> &nums) {

        vector<vector<int>> res;
        int n = nums.size();
        for (int mask = 0; mask < (1 << n); mask++) {
            vector<int> p;
            for (int i = 0; i < n; i++)
                if (mask & (1 << i))
                    p.push_back(nums[i]);
            res.push_back(p);
        }
        return res;
    }
};

• Java

class Solution {
    public List<List<Integer>> subsets(int[] nums) {

        ArrayList<List<Integer>> res = new ArrayList<>();
        ArrayList<Integer> p = new ArrayList<>();

        int n = nums.length;
        for (int mask = 0; mask < (1 << n); mask++) {
            p.clear();
            for (int i = 0; i < n; i++) {
                if ((mask & (1 << i)) != 0)
                    p.add(nums[i]);
            }
            res.add(new ArrayList<>(p));
        }
        return res;
    }
}

时空复杂度分析

• 时间复杂度： O ( 2 n ) O(2^n) O(2n)，n为数组长度。

• 空间复杂度：考虑存储结果的数组 O ( 2 n × n ) O(2^n \times n) O(2n×n)。

Leetcode 0090 子集II

题目描述：Leetcode 0090 子集II

分析

• 本题的考点：递归回溯。

• Leetcode 0078 子集中可以使用位运算，是因为数组中的元素都不相同。这一题不能使用位运算，因为存在重复元素。

• 首先对数组进行排序，这样方便处理重复元素，对于出现多次的元素，在暴搜过程中直接过滤掉即可。

• 这一题的做法和Leetcode 0040 组合总和II的做法十分类似。

代码

• C++

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;

    vector<vector<int>> subsetsWithDup(vector<int> &nums) {

        sort(nums.begin(), nums.end());
        dfs(nums, 0);
        return res;
    }

    // u: 当前考察的是nums[u]
    void dfs(vector<int> &nums, int u) {

        if (u == nums.size()) {
            res.push_back(path);
            return;
        }

        int k = u + 1;
        while (k < nums.size() && nums[k] == nums[u]) k++;

        for (int i = 0; i <= k - u; i++) {
            dfs(nums, k);
            path.push_back(nums[u]);
        }

        for (int i = 0; i <= k - u; i++) path.pop_back();
    }
};

• Java

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();

    public List<List<Integer>> subsetsWithDup(int[] nums) {

        Arrays.sort(nums);
        dfs(nums, 0);
        return res;
    }

    private void dfs(int[] nums, int u) {

        if (u == nums.length) {
            res.add(new LinkedList<>(path));
            return;
        }

        int k = u + 1;
        while (k < nums.length && nums[k] == nums[u]) k++;

        for (int i = 0; i <= k - u; i++) {
            dfs(nums, k);
            path.add(nums[u]);
        }

        for (int i = 0; i <= k - u; i++) path.removeLast();
    }
}

时空复杂度分析

• 时间复杂度： O ( 2 n ) O(2^n) O(2n)，n为数组长度。

• 空间复杂度：考虑结果的存储 O ( 2 n ) O(2^n) O(2n)。