78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。


输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]


输入：nums = [0] 输出：[[],[0]]


  • 1 <= nums.length <= 10
  • -10 <= nums[i] <= 10
  • nums 中的所有元素 互不相同

方法一：从每个数选或不选考虑

（1）需要做n次选择：所以，需要用index来记录已经做 了几次选择。

（2）每个数有两种选择，选或不选。

当数不选的时候，直接写dfs(index+1);

当数选的 时候，需要回溯。

（3）关于dfs要写多个的理解：

由于每次可以有两种选择，所以在一个dfs函数里面应该有两个dfs。而且这做完一次dfs需要回溯。

【深度优先搜索】子集| &&子集||_深度优先

class Solution {
public:
    int n;
    vector<int>a;
    vector<vector<int>>res;
    vector<int>path;
    void dfs(int index){
        if(index==n){
            res.push_back(path);
            return;
        }
      //不选
        dfs(index+1);
      //选
        path.push_back(a[index]);
        dfs(index+1);
        path.pop_back();
    }
    vector<vector<int>> subsets(vector<int>& nums) {
      a=nums;
      n=a.size();
      dfs(0);
      return res;
    }
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.

方法二：从每次可以选的数考虑

因为组合是无序的，如果从每次可以选的数角度出发，那么每次可以选的数下标index~n。

因为要求所有组合情况，所以每次选择完后直接计入res。

因为每次做的选择都是在合法的范围，所以不需要return去掉不合法的情况

class Solution {
public:
    int n;
    vector<int>a;
    vector<vector<int>>res;
    vector<int>path;
    void dfs(int index){
        res.push_back(path);
        for(int i=index;i<a.size();i++){
          path.push_back(a[i]);
          dfs(i+1);
          path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
      a=nums;
      n=a.size();
      dfs(0);
      return res;
    }
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.

子集||

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

 90. 子集 II

去重：

首先要排序，排序因为序列递增，所以当a[i]==a[i-1]时，说明a[i]这个数在之前就被用过，如果再用，那么就会有重复的情况。所以，这个去重逻辑的前提是序列是单调不减的。

if(i>index&&a[i]==a[i-1])continue;

也可以使用set进行去重。

class Solution {
public:
    vector<vector<int>>res;
    vector<int>path;
    vector<int>a;
    int n;
    void dfs(int index){
        //每次做选择后都要计入res
        res.push_back(path);
        //每次选择从index~n。如果
    for(int i=index;i<n;i++){
        if(i>index&&a[i]==a[i-1])continue;
        path.push_back(a[i]);
        dfs(i+1);
        path.pop_back();
    }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
          a=nums;
          sort(a.begin(),a.end());
          n=nums.size();
          dfs(0);
          return res;
    }
};
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.