[Leetcode 105] 90 Subsets II

Problem:

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],
  []
]

Analysis:

This is a viration of basic DFS. The given int vector contains duplicated elements. To avoid dup-enumeration, we need first sort the given vector so that the enumeration is ordered. Then we need an extra signal array to indicate whether an element is accessed. We pick an element only if 1) it's different from the previous element or 2) it's the same as the previous one but the previous element has already be selected. In this way, we can ensure no duplicated subsets are generated.

Code:

class Solution {
public:
    vector<vector<int> > res;
    vector<int> tmp;
    int *sig;
    int size;

    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        res.clear();
        tmp.clear();
        
        size = S.size();
        sig = new int[size];
        for (int i=0; i<size; i++)
            sig[i] = 0;

        std::sort(S.begin(), S.end());
        solve(0, S);
        
        return res;
    }
    
private:
    bool solve(int n, vector<int> &S) {
        res.push_back(tmp);

        if (n == size) return true;

        for (int i=n; i<size; i++) {
            if ((i==0) || (S[i-1] != S[i]) || (S[i-1] == S[i] && sig[i-1])) {
                sig[i] = 1;
                tmp.push_back(S[i]);
                
                solve(i+1, S);
                
                tmp.pop_back();
                sig[i] = 0;
            }
        }
        
        return false;
    }
};