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;
}
};