[leetcode 78 & 90, Medium] Subsets I and II

Problem:

I: 

Given a set of distinct integers, 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,3], a solution is:

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

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

Analysis:

Solutions:

(I) Recursive method:

void getCombine(vector<vector<int> > &setCombine, vector<int> &combine, vector<int> &S, int startIndex, int num){
        if(num==1){
            for(int i=startIndex; i<S.size(); ++i){
                combine.push_back(S[i]);
                setCombine.push_back(combine);
                combine.pop_back();
            }
        }else{
            for(int i=startIndex; i<S.size(); ++i){
                combine.push_back(S[i]);
                getCombine(setCombine, combine, S, i+1, num-1);
                combine.pop_back();
            }
        }
    }
    
    vector<vector<int> > subsets(vector<int> &S) {
        
        std::sort(S.begin(), S.end());
        
        vector<vector<int> > colSubset;
        vector<int> subset;
        colSubset.push_back(subset); //Empty subset.
        
        for(int k=1; k<=S.size(); ++k)
            getCombine(colSubset, subset, S, 0, k);
        return colSubset;
    }

Non-Recursive method:

    vector<int> Union(const vector<int>& left, const vector<int>& right)
    {
        vector<int> r_set;
        for(int i = 0; i < left.size(); ++i)
            r_set.push_back(left[i]);
            
        for(int i = 0; i < right.size(); ++i)
            r_set.push_back(right[i]);
            
        return r_set;
    }
    
    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int> > r_subsets;
        vector<int> empty;
        r_subsets.push_back(empty);
        if(S.empty())
            return r_subsets;

        sort(S.begin(), S.end());

        int max_size = S.size();
        vector<vector<vector<int> > > subsets_by_size;
        subsets_by_size.resize(max_size);
        for(int size = 0; size < max_size; ++size) {
            if(size == 0) {
                for(int i = 0; i < S.size(); ++i) {
                    vector<int> subset;
                    subset.push_back(S[i]);
                    subsets_by_size[size].push_back(subset);
                }
            } else {
                for(int i = 0; i < subsets_by_size[0].size(); ++i) {
                    for(int j = 0; j < subsets_by_size[size - 1].size(); ++j) {
                        if(subsets_by_size[0][i][0] < subsets_by_size[size - 1][j][0])
                            subsets_by_size[size].push_back(Union(subsets_by_size[0][i], subsets_by_size[size - 1][j]));
                    }
                }
            }
        }
        
        for(int i = 0; i < max_size; ++i) {
            for(int j = 0; j < subsets_by_size[i].size(); ++j)
                r_subsets.push_back(subsets_by_size[i][j]);
        }
        
        return r_subsets;
    }

( II)

    vector<int> Union(const vector<int>& left, const vector<int>& right)
    {
        vector<int> r_set;
        for(int i = 0; i < left.size(); ++i)
            r_set.push_back(left[i]);
            
        for(int i = 0; i < right.size(); ++i)
            r_set.push_back(right[i]);
            
        return r_set;
    }
    
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        vector<vector<int> > r_subsets;
        vector<int> empty;
        r_subsets.push_back(empty);
        if(S.empty())
            return r_subsets;

        sort(S.begin(), S.end());

        int max_size = S.size();
        vector<vector<vector<int> > > subsets_by_size;
        subsets_by_size.resize(max_size);
        for(int size = 0; size < max_size; ++size) {
            if(size == 0) {
                for(int i = 0; i < max_size;) {
                    vector<int> subset;
                    if(i == max_size - 1 || S[i] < S[i + 1]) {
                        subset.push_back(S[i]);
                        subsets_by_size[size].push_back(subset);
                        ++i;
                    } else {
                        int sum_same = 0;
                        for(int j = i; j < max_size; ++j) {
                            if(S[i] == S[j]) ++sum_same;
                            else break;
                        }
                            
                        for(int j = 0; j < sum_same; ++j) {
                            subset.push_back(S[i]);
                            subsets_by_size[size].push_back(subset);
                        }
                        i += sum_same;
                    }
                }
            } else {
                for(int i = 0; i < subsets_by_size[0].size(); ++i) {
                    for(int j = 0; j < subsets_by_size[size - 1].size(); ++j) {
                        if(subsets_by_size[0][i][0] < subsets_by_size[size - 1][j][0])
                            subsets_by_size[size].push_back(Union(subsets_by_size[0][i], subsets_by_size[size - 1][j]));
                    }
                }
            }
        }
        
        for(int i = 0; i < max_size; ++i) {
            for(int j = 0; j < subsets_by_size[i].size(); ++j)
                r_subsets.push_back(subsets_by_size[i][j]);
        }
        
        return r_subsets;
    }

Java :

Python: