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