[LeetCode] 78、子集

题目描述

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例：

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

解题思路

含有n个不重复数字的集合的子集数一共有$2^n$个（包含空集和原集合本身）。这是一个典型的递归回溯问题，类似的题目及题解见精选题解。（39、40、46、47、77、78、90）

• 位运算：我们所有取的组合数为一个指数函数（$2^n$个为一可以计算出来的固定的数字，用于循环）。

  假设输入是1、2、3。首先全部的子集为【000】【001】【010】【100】【011】【101】【110】【111】，1表示这一位的数字存在，例如 【010】 表示只含有2（也是集合中的第二个元素）。

  由此发现子集所代表的二进制数全部小于int numOfSubsets = 1 << length;（关键）

  so：第一层循环：for(int i = 0; i < (1 << size); i++)，其中i代表目前生成的是第i个子集，然后后面需要根据i的二进制表示中1的位置，生成对应的子集即可。（代码）

  问题：如果nums数组的size大于32会有问题？（注意unsigned int bitMask = 1;一定要用``unsigned int`）

  是的，64位以内可以用unsigned long long，再大了就不行了，不过$2^{31}$已经是21亿了，再大系统的内存就吃不消了，所以真实世界里枚举子集的情况也不会太大。$O(2^{32})$已经很大了，实测可以通过。

• 回溯（代码3，这里叫“深度优先遍历”解法可能更好，基本解法）：回溯递归题目画出递归树是关键！在数组nums的子集中，对于nums中的每个数字，只有两种情况：有/没有。据此进行dfs即可。（在叶子节点处“结算”）

  

  注：回溯函数一般都写作helper()，深度优先搜索函数一般都写作dfs()。回溯和深度优先搜索的区别不大，目前还没搞清楚。

  我觉得很多题解包括官方题解 都把纯递归给写成了回溯。 回溯一定要体现失败后终止 退回上一层这个过程 这个题里并没有任何地方会"失败"。 真正的回溯可以参考N-Queen那道题，当没有任何格子可以放棋子时退回上一层。

  回溯本质上就是递归。

  另一个角度理解：到达终点回退也是回溯啊，即递归到数组末尾就回退。基本上求解集的全都可以用回溯。只是这题比较特殊，没有剪枝，而且树中所有节点都是一组解。当到达树的最低端就会自动回溯；（所以这不是一个非常典型的回溯题目，叫dfs可能更合适）

补充：详细介绍递归、回溯的套路。

参考代码

位运算（奇技淫巧，不推荐）

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res;
        int length = nums.size();
        if(length == 0){
            vector<int> temp;  // 空集
            res.push_back(temp);
            return res;
        }
        
        int numOfSubsets = 1 << length;  // 子集数（可以算出来）
        for(int i = 0; i < numOfSubsets; i++){  // i代表目前是生成的第几个子集（利用其二进制表示生成子集）
            unsigned int bitMask = 1;   // 有关位运算时用 unsigned int
            vector<int> temp;
            for(int j = length - 1; j >= 0; j--){    // 判断集合中的第j个数字是否应该存在
                if((i & bitMask) != 0)          // 根据i的二进制中1的位置取得子集
                    temp.push_back(nums[j]);
                bitMask = bitMask << 1;
            }
            
            res.push_back(temp);
        }
        
        return res;
    }
    
};

回溯1（这种方法更像是深度优先遍历，好理解，推荐）

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int> > res;
        int length = nums.size();
        if(length == 0){
            vector<int> temp;  // 空集
            res.push_back(temp);
            return res;
        }
        
        vector<int> temp;
        dfs(nums, 0, res, temp);
        
        return res;
    }
    
    // 个人偏爱这种写法
    void dfs(vector<int>& nums, int start, vector<vector<int> > &res, vector<int> &temp){
    	// 这种写法只有遍历完整个数组的时候才“结算”
        if(start == nums.size()){
            res.push_back(temp);
            return;
        }
        
        // 当前的数字 可选，也可以不选（就这两种情况）
        // 不选，直接进入下一层
        dfs(nums, start + 1, res, temp);  // 刚开始这一行没写，导致错误（只写了下面三行）
        
        // 选了，进入下一层
        temp.push_back(nums[start]);
        dfs(nums, start + 1, res, temp);
        temp.pop_back();  // temp传的是引用，所以pop_back()必写。如果是值传递的话，其实可以不写
    }
    
};

回溯2（刚开始觉得不是很好理解，看多了就觉得还好了。也要会！）

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int> > res;
        vector<int> tmp;
        
        length = nums.size(); 
        dfs(nums, res, tmp, 0);
        return res;
    }
    
    void dfs(vector<int>& nums, vector<vector<int> > &res, vector<int> &tmp, int startNum){
    	// 这种写法，没有显式的递归终止，树中所有节点都是一组解
        res.push_back(tmp);
        
        // 相当于遍历选择列表
        for(int i = startNum; i < length; i++){
            tmp.push_back(nums[i]);
            dfs(nums, res, tmp, i + 1);
            tmp.pop_back();
        }
    }

private:
    int length;
};