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:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        vector<vector<int> > result;  
        vector<int> temp;
        vector<int> dup;
        result.push_back(temp);  
        sort(S.begin(), S.end());  
        for(int i = 0; i < S.size(); i++)  
        {  
            dup.clear();
            dup.push_back(S[i]);
            while(i < S.size()-1 && S[i] == S[i+1])
                {
                    dup.push_back(S[i]);
                    i++;
                }
            int size = result.size();  
            for(int j = 0; j < size; j++)  
            {
                temp = result[j];
                int index = 0;
                while(!dup.empty() && index < dup.size())
                {
                    temp.push_back(dup[index]);  
                    result.push_back(temp);
                    index++;
                }
            }  
        }  
        return result;  
    }
};

Round 2:

class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        vector<vector<int> > result;
        if(S.size() == 0)
            return result;
        std::sort(S.begin(), S.end());
        vector<int> cur;
        dfs(S, result, 0, cur);
        return result;
    }
private:
    void dfs(vector<int> &input, vector<vector<int> > &result, int index, vector<int> &cur)
    {
        if(index >= input.size())
        {
            result.push_back(cur);
            return;
        }
        int count = 1;
        int iter = index;
        while(iter+1 < input.size() && input[iter] == input[iter+1])
        {   
            count++;
            iter++;
        }
        dfs(input, result, index+count, cur);
        for(int i = 0; i < count; i++)
        {
            cur.push_back(input[index]);
            dfs(input, result, index+count, cur);
        }
		while(cur.size() > 0 && cur.back() == input[index])
			cur.pop_back();
        
    }
};