LeetCode_Subsets II

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 {
public:
void subsetsWithoutDup(vector<vector<int> > &ans, vector<int> &s)
{
vector<int> empty;
ans.push_back(empty);
int size = s.size();
if (size == 0)
{
return;
}
for (int i = 0; i < size; ++i)
{
int num = s[i];
int len = ans.size();
for (int j = 0; j < len; ++j)
{
vector<int> tmp = ans[j];
tmp.push_back(num);
ans.push_back(tmp);
}
}
}

vector<vector<int> > subsetsWithDup(vector<int> &s)
{
vector<vector<int> > ans;
if (s.size() == NULL)
{
return ans;
}
sort(s.begin(), s.end());
int size = s.size();
vector<int> dup;
int last = s[0];
int count = 1;
int i = 1;
for (; i < size; ++i)
{
if (s[i] == last)
{
++count;
--size;
--i;
s.erase(s.begin() + i);
}
else
{
if (count > 1)
{
dup.push_back(last);
dup.push_back(count);
--i;
s.erase(s.begin() + i);
--size;
}
last = s[i];
count = 1;
}
}
if (count > 1)
{
dup.push_back(last);
dup.push_back(count);
--i;
s.erase(s.begin() + i);
--size;
}
subsetsWithoutDup(ans, s);
int num = 0;
int total = dup.size();
while (num < total)
{
int size = ans.size();
int nNum = dup[num];
int nCount = dup[num + 1];
num += 2;
for (int i = 0; i < nCount; ++i)
{
int start = ans.size() - size;
int end = ans.size();
for (int j = start; j < end; ++j)
{
vector<int> tmp = ans[j];
tmp.push_back(nNum);
ans.push_back(tmp);
}
}
}
int ansNum = ans.size();
for (int i = 0; i < ansNum; ++i)
{
sort(ans[i].begin(), ans[i].end());
}
return ans;
}
};