从零学算法78

78.给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。
解集不能包含重复的子集。你可以按任意顺序返回解集。
示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
输入：nums = [0]
输出：[[],[0]]

如果将该题想象成一棵 n 叉树，进行 dfs，那么其实遍历时走过的每个路径都是子集。比如例子 1
```
  		1
  	2		3
  3
```
为了防止重复组合，所以在构建新的子集时，比如 [1,3] 我们继续构建时，不会往前取数字（取末尾的 3 前面的数字）构建成新的子集，比如得到 [1,3,2]，这也就是为什么上面那棵树是这样的。所以比如 [1,2,3] ，我们得到 [1,2,3] 后不可能回溯成 [1,3] 然后得到 [1,3,2]，所以每次的下一层递归，从当前层递归的数组的下标 +1 开始，具体看代码

  public List<List<Integer>> subsets(int[] nums) {
      List<List<Integer>> list = new ArrayList<>();
      backtrack(list, new ArrayList<>(), nums, 0);
      return list;
  }
  
  private void backtrack(List<List<Integer>> list, List<Integer> tempList, int[] nums, int start) {
      //走过的所有路径都是子集的一部分，所以都要加入到集合中
      list.add(new ArrayList<>(tempList));
      for (int i = start; i < nums.length; i++) {
          //做出选择
          tempList.add(nums[i]);
          //递归，i+1 防止重复结果
          backtrack(list, tempList, nums, i + 1);
          //撤销选择
          tempList.remove(tempList.size() - 1);
      }
  }

位运算：其实在构建每个子集时都可以看成，每个数都有两种状态，加入子集或者不加入。设加入为 1，不加入为 0，数组长度为 n，就能把每个子集看做 n 位二进制数，那么总个数就是 2ⁿ。比如 [1,2,3]，每个子集都能看做三位的二进制数，[] 就是每个数都不选即 000，[1,3] 就对应 101。
因此，比如例子 1，我们只需要遍历这 n（该例中为 8）个数，范围为 0~7，比如 6 对应为 110，就表示该子集为 [2,3]，再比如 3 对应为 011，表示子集 [1,2]（因为低位表示数组下标小的数）

  public List<List<Integer>> subsets(int[] nums) {
      List<List<Integer>> res = new ArrayList<>();
      int len = nums.length;
      // 子集个数
      int resCount = 1<<len;
      // i 其实就是每种子集对应的二进制数的十进制
      for(int i=0;i<resCount;i++){
          List<Integer> list = new ArrayList<>();
          // 看是否包含 nums 中某个数
          for(int j=0;j<len;j++){
          	// 如果包含就添加到 list
              if((i>>j&1)==1)list.add(nums[j]);
          }
          res.add(list);
      }
      return res;
  }

非递归：我们先加入一个空集，遍历时 nums 时每次都把 nums[i] 加到之前的子集中构建新子集，遍历完也就得到了全部子集。比如例子 1 我们会依次得到： []->[[],1]->[[],1,2,12]->[[],1,2,12,3,13,23,123]

  public List<List<Integer>> subsets(int[] nums) {
      List<List<Integer>> res = new ArrayList<>();
      res.add(new ArrayList<>());
      for(int num : nums){
          int size = res.size();
          for(int j=0;j<size;j++){
              List<Integer> tempList = new ArrayList<>(res.get(j));
              tempList.add(num);
              res.add(tempList);
          }
      }
      return res;
  }

强行递归也可以，其实就是递归形式的循环

  public List<List<Integer>> subsets(int[] nums) {
      List<List<Integer>> res = new ArrayList<>();
      res.add(new ArrayList<>());
      dfs(nums,res,0);
      return res;
  }
  public void dfs(int[] nums,List<List<Integer>> res,int index){
      if(index >= nums.length)return;
      for(int i=0,j=res.size();i<j;i++){
          List<Integer> list = new ArrayList(res.get(i));
          list.add(nums[index]);
          res.add(list);
      }
      dfs(nums,res,index+1);
  }

递归：还是上面的思路，我们在构建一种子集时，都可以看做对每个数选或不选。比如 nums：[1,2,3] 选择 12,不选 3，得到 011，也就是说完全可以当做一个二叉树，因为对于每个数只有选或不选两种可能，所以递归部分就写做选择的过程

  public List<List<Integer>> subsets(int[] nums) {
      List<List<Integer>> res = new ArrayList<>();
      dfs(res, new ArrayList<>(), nums, 0);
      return res;
  }
  public void dfs(List<List<Integer>> res, List<Integer> list, int[] nums, int index){
      if(index == nums.length){
          res.add(new ArrayList<>(list));
          return;
      }
      // 不选，直接继续递归
      dfs(res, list, nums, index + 1);
      // 选择（加入 list）
      list.add(nums[index]);
      // 选完再递归
      dfs(res, list, nums, index + 1);
      // 撤销选择
      list.remove(list.size() - 1);
  }