LeetCode Subsets II

class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        int len = S.size();
        vector<vector<int> > res;
        vector<int> subset;
        if (len < 1) {
            res.push_back(subset);
            return res;
        }
        sort(S.begin(), S.end());
        vector<int> stat;
        vector<int> nums;

        int count = 1;
        int cur = S[0];
        int last = cur;
        for (int i=1; i<len; i++) {
            cur = S[i];
            if (cur != last) {
                stat.push_back(count);
                nums.push_back(last);
                last = cur;
                count = 0;
            }
            count++;
        }
        stat.push_back(count);
        nums.push_back(last);

        dfs(nums, stat, res, subset, 0);
    }

    void dfs(vector<int> &nums, vector<int> &stat, vector<vector<int> > &res, vector<int> &subset, int k) {
        if (k >= nums.size()) {
            res.push_back(subset);
            return;
        }

        int cnt = stat[k];

        int old = subset.size();

        for (int i=0; i <= cnt; i++) {
            dfs(nums, stat, res, subset, k + 1);
            subset.push_back(nums[k]);
        }
        subset.resize(old);
    }
};

常规dfs

第二轮：

Given a collection of integers that might contain duplicates, S, return all possible subsets.

Note:

• Elements in a subset must be in non-descending order.
• The solution set must not contain duplicate subsets.

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

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]
简单一些

class Solution {
private:
    vector<vector<int> > res;
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        sort(S.begin(), S.end());
        res.clear();
        
        vector<int> current;
        dfs(S, 0, current);
        return res;
    }
    void dfs(vector<int>& S, int pos, vector<int>& current) {
        int len = S.size();
        if (pos == len) {
            res.push_back(current);
            return;
        }
        
        int cnt = 1;
        int idx = pos;
        while ((idx + 1) < len && S[idx] == S[idx + 1]) {
            idx++, cnt++;
        }
        
        for (int i=0; i<=cnt; i++) {
            dfs(S, pos + cnt, current);
            current.push_back(S[pos]);
        }
        current.resize(current.size() - cnt - 1);
    }
    
};

深夜来个非递归版：

// 0:30
class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int len = nums.size();
        
        vector<vector<int>> res(1);
        
        
        for (int i=0; i<len; i++) {
            if (i != 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            
            int last_size = res.size();
            int k = i;
            while (k < len && nums[k] == nums[i]) {
                k++;
            }
            for (int j=0; j<last_size; j++) {
                for (int c=1; c<=k - i; c++) {
                    res.emplace_back(res[j]);
                    for (int x=0; x < c; x++) {
                        res[res.size() - 1].push_back(nums[i]);
                    }
                }
            }
        }
        
        return res;
    }
};