78. Subsets（图解）

78. Subsets

Given a set of distinct integers, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

Input: nums = [1,2,3]
Output:
[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

Solution

C++

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int> > res;
        vector<int> cur;
        dfs(nums, 0, res, cur);
        return res;
    }
    
    void dfs(vector<int>& nums, int index, vector<vector<int> >& res, vector<int>& cur) {
        if(index == nums.size()) {
            res.push_back(cur);
            return;
        }
        cur.push_back(nums[index]);
        dfs(nums, index+1, res, cur);
        cur.pop_back();
        dfs(nums, index+1, res, cur);
    }
};

C++ Sol2

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int> > res;
        vector<int> cur;
        dfs(nums, 0, res, cur);
        return res;
    }
    
    void dfs(vector<int>& nums, int index, vector<vector<int> >& res, vector<int>& cur){
        res.push_back(cur);
        
        for(int i = index; i < nums.size(); ++i){
            cur.push_back(nums[i]);
            dfs(nums, i+1, res, cur);
            cur.pop_back();
        }
    }
};

Explanation
dfs:

复杂度$O(2^N)$

Similar Questions

Subset II

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int> > res;
        vector<int> cur;
        sort(nums.begin(),nums.end());   //先排序
        dfs(nums, 0, res, cur);
        return res;
    }
    
    void dfs(vector<int>& nums, int index, vector<vector<int> >& res, vector<int>& cur){
        res.push_back(cur);
        
        for(int i = index; i < nums.size(); ++i){
            if(i > index && nums[i] == nums[i-1]) continue;   //防止重复
            cur.push_back(nums[i]);
            dfs(nums, i+1, res, cur);
            cur.pop_back();
        }
    }
};

Permutations

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int> > res;
        dfs(nums, 0, res);
        return res;
    }
    
    void dfs(vector<int>& nums, int index, vector<vector<int> >& res) {
        if(index == nums.size()) {
            res.push_back(nums);
            return;
        }
        for(int i = index; i < nums.size(); ++i) {
            swap(nums[i], nums[index]);
            dfs(nums, index+1, res);
            swap(nums[i], nums[index]);
        }
    }
};

Permutations II

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());   //先排序
        vector<vector<int> > res;
        dfs(nums, 0, res);
        return res;
    }
    
    void dfs(vector<int> nums, int index, vector<vector<int> >& res) {   //nums has no reference
        if(index == nums.size()) {
            res.push_back(nums);
            return;
        }
        for(int i = index; i < nums.size(); ++i) {
            if(i > index && nums[i] == nums[index]) continue;   //防止重复 注意是num[index]
            swap(nums[i], nums[index]);
            dfs(nums, index+1, res);
            //swap(nums[i], nums[index]);
        }
    }
};

Combination Sum

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<vector<int> > res;
        vector<int> cur;
        dfs(candidates, 0, target, cur, res);
        return res;
    }
    
    void dfs(vector<int>& c, int index, int target, vector<int>& cur, vector<vector<int> >& res) {
        if(target == 0) {
            res.push_back(cur);
            return;
        }
        for(int i = index; i < c.size(); i++) {
            if(target < c[i]) break;
            cur.push_back(c[i]);
            dfs(c, i, target-c[i], cur, res);
            cur.pop_back();
        }
        
    }
};

Combination Sum II

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<vector<int> > res;
        vector<int> cur;
        dfs(candidates, 0, target, cur, res);
        return res;
    }
    
    void dfs(vector<int>& c, int index, int target, vector<int>& cur, vector<vector<int> >& res) {
        if(target == 0) {
            res.push_back(cur);
            return;
        }
        for(int i = index; i < c.size(); i++) {
            if(target < c[i]) break;
            if(i > index && c[i]==c[i-1]) continue;   //防止重复
            cur.push_back(c[i]);
            dfs(c, i+1, target-c[i], cur, res);   //注意是i+1
            cur.pop_back();
        }
        
    }
};

Palindrome Partitioning

class Solution {
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string> > res;
        vector<string> cur;
        dfs(s, 0, cur, res);
        return res;
    }
    
    void dfs(string& s, int index, vector<string>& cur, vector<vector<string> >& res) {
        if(index == s.length()) {
            res.push_back(cur);
            return;
        }
        for(int i = index; i < s.size(); i++) {
            string tmp = s.substr(index,i-index+1);
            if(!isPal(tmp)) continue;
            cur.push_back(tmp);
            dfs(s,i+1,cur,res);
            cur.pop_back();
        }
    }
    
    bool isPal(string& s) {
        for(int i = 0; i < s.length()/2; ++i) {
            if(s[i] != s[s.length()-i-1]) return false;
        }
        return true;
    }
};