LeetCode 90. Subsets II

最新推荐文章于 2020-04-08 11:42:57 发布

LegionBUPT

最新推荐文章于 2020-04-08 11:42:57 发布

阅读量393

点赞数

分类专栏： LeetCode 文章标签： leetcode array backtrack iterative subsets

本文链接：https://blog.csdn.net/ljwinds/article/details/69396336

版权

LeetCode 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

LeetCode 90. Subsets II

原题目：
Given a collection of integers that might contain duplicates, nums, return all possible subsets.

Note: The solution set must not contain duplicate subsets.

For example,
If nums = [1,2,2], a solution is:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

题目翻译：
给出一个可能包含重复元素的整型数组，找到所有该数组的子集，返回的结果不能包含重复的子集。

思路：
这题是 LeetCode 78. Subsets的一道变式题，在原题的基础上增加了可能包含重复元素的限制。关于原题的详细解答可以参照本人另一篇文章：LeetCode 78. Subsets的三种解法。
这题同样也可以使用回溯法（Backtracking）和迭代法（Iterative）解决，而位操作（Bit Manipulation）需要事先知道返回结果集的大小，除非先进行一次遍历求得结果集大小，而且各个变量的中间值也不是2的幂次方，因此就不在此给出位操作的方案。

要点：
1）尽量从原题的基础上进行思考，找出其中的区别，在原代码上修改，利用题目和题目之间的关联性。
2）这道题需要先对原数组进行排序，目前还不知道不排序该怎么做。

方案一：回溯（Backtracking）
1）可以在递归之前用一个unordered_set保存出现过的元素。
AC代码如下：（C++， 13ms）

class Solution {
public:
    void backtrack(int start, vector<int>& sub, vector<int>& nums, vector<vector<int>>& subs) {
        subs.push_back(sub);
        unordered_set<int> uset;
        for (int i = start; i < nums.size(); i++) {
            if (uset.find(nums[i]) == uset.end()) {
                sub.push_back(nums[i]);
                backtrack(i + 1, sub, nums, subs);
                sub.pop_back();
                uset.insert(nums[i]);
            }
        }
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> subs;
        vector<int> sub;
        sort(nums.begin(), nums.end());
        backtrack(0, sub, nums, subs);
        return subs;
    }
};

2）由于数组事先已经过排序，因此不需要再用额外的unordered_set去判断重复元素，直接判断nums[i]和nums[i - 1]是否相等就行了。
AC代码如下：（C++， 13ms）

class Solution {
public:
    void backtrack(int start, vector<int>& sub, vector<int>& nums, vector<vector<int>>& subs) {
        subs.push_back(sub);
        for (int i = start; i < nums.size(); i++) {
            if (i == start || nums[i] != nums[i - 1]) {
                sub.push_back(nums[i]);
                backtrack(i + 1, sub, nums, subs);
                sub.pop_back();
            }
        }
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> subs;
        vector<int> sub;
        sort(nums.begin(), nums.end());
        backtrack(0, sub, nums, subs);
        return subs;
    }
};

方案二：迭代（Iterative）
仍旧参照LeetCode 78. Subsets的三种解法中方案二的思想，判断下一个元素是否是重复元素：
若nums[i - 1] != nums[i]，则直接按照方案二来做；
若nums[i - 1] == nums[i]，则只复制最后增加的那部分子集，即将内循环迭代的初始值移动至最后一部分。
AC代码如下：（C++， 6ms）

class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &nums) {
        sort(nums.begin(), nums.end());
        vector<vector<int>> subs = {{}};
        for (int i = 0; i < nums.size(); i++) {
            int start, size;
            if (i == 0 || nums[i] != nums[i - 1])   start = 0;
            else                                    start = size;
            size = subs.size();
            for (int j = start; j < size; j++) {
                subs.push_back(subs[j]);
                subs.back().push_back(nums[i]);
            }

        }
        return subs;
    }
};