Subsets

Subsets I:

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

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

New Version: we can find that if we have the subsets of N-1 numbers, then the result is composed of adding the Nth number to each of the subsets of N-1 numbers plus the original subsets of N-1 numbers, i.e. S(N) = S(N-1) + (adding N to S(N-1)). 

Runtime: 4ms

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int> > result;
        if(nums.empty()) return result;
        
        sort(nums.begin(), nums.end());
        vector<int> temp;
        
        //manipulate the first number in nums
        result.push_back(temp);
        temp.push_back(nums[0]);
        result.push_back(temp);
        int level = 1;
        
        //manipulate the remaining numbers in nums
        while(level < nums.size()){
            int n = result.size();
            for(int i = 0; i < n; i++){
                temp = result[i];
                temp.push_back(nums[level]);
                result.push_back(temp);
            }
            level++;
        }
        
        return result;
    }
};

Analyse: Each number has two states: selected or not selected. Recursively invoke the choose function until the step equals to the size. Then construct a vector to store all selected numbers, and push it to the result vector.

Runtime: 8ms.

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int> > result;
        sort(nums.begin(), nums.end());
        vector<bool> selected(nums.size(), false);
        subset(nums, selected, 0, result);
        
        return result;
    }
    
    void subset(vector<int> &nums, vector<bool> &selected, int step, vector<vector<int> > &result){
        if(step == nums.size()){
            vector<int> temp;
            for(int i = 0; i < step; i++){
                if(selected[i]) temp.push_back(nums[i]);
            }
            result.push_back(temp);
            return;
        }
        
        //not choose the number
        selected[step] = false;
        subset(nums, selected, step + 1, result);
        //choose the number
        selected[step] = true;
        subset(nums, selected, step + 1, result);
    }
};

Subsets II:

Given a collection of integers that might contain duplicates, nums, 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 nums = [1,2,2], a solution is:

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

Analyse: It is the same as subsets I except that we need to set a variable keep the place where we start to push the last number. 

Runtime: 12ms

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int> > result;
        if(nums.empty()) return result;
        
        sort(nums.begin(), nums.end());
        vector<int> temp;
        
        //manipulate the first number in the nums
        result.push_back(temp);
        temp.push_back(nums[0]);
        result.push_back(temp);
        int level = 1;
        int index = 1; //the place where push the first number
        
        //manipulate remaining numbers in the nums
        while(level < nums.size()){
            int i;
            if(nums[level] == nums[level - 1])
                i = index;
            else i = 0;
            index = result.size();
            int n = result.size();
            for(; i < n; i++){
                temp = result[i];
                temp.push_back(nums[level]);
                result.push_back(temp);
            }
            level++;
        }
        return result;
    }
};