【小白爬Leetcode78】4.1 子集 Subsets

Leetcode 78 $medium$

点击进入原题链接：Leetcode 78 子集 Subsets

题目

discription

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

Note: The solution set must not contain duplicate subsets.

Example:

中文描述

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

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

示例：

解法一：递归法

选子集，具体到每一个元素身上，无非两种选择：选这个元素或者不选这个元素

因此有了这样一个思想，遍历nums数组，选择当前元素nums[i]是一个分支，不选择nums[i]又是一个分支，每一个分支下面又有新的分支，如图所示：图片来源：小象学院 点击进入原视频

实现代码如下：

class Solution {
public:
	//先定义递归过程
    void subsets_builder(vector<int>& nums,vector<vector<int>>& res,vector<int>& items,int idx){
        if(idx>=nums.size()) return;
		//选择nums[idx]的分支
        items.push_back(nums[idx]);
        res.push_back(items);
        subsets_builder(nums,res,items,idx+1);
		//不选择nums[idx]的分支
        items.pop_back();
        subsets_builder(nums,res,items,idx+1);
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res; //最后要返回的数组
        vector<int>items; //每次要push_back进res里的子集
        res.push_back(items);
        int idx = 0; //从0开始遍历nums数组的元素
        subsets_builder(nums,res,items,idx);
        return res;
    }
};

时间复杂度： 由于对于每一个元素来说，都需要有一个二分，所以时间复杂度为O(2ⁿ)
空间复杂度： 没有用到额外的容器，因此为 O(1)

小改进

上面的写法存在不直观的问题：

1. 左分支（包含nums[i]）的时候向res中push_back当前的items，为了避免重复，右分支的是时候没有对res写入。这样会导致漏了一个情况[]，需要手动补全，也很不方便。
   解决方法： 其实每个子集无非是对非一个nums里的每一个元素做选或不选的选择题（这一点和思路二很像），因此递归的所有子分支的末尾的items都是一个完整的子集，所以res.push_back(items)其实可以放在最后的结束递归条件里，即：

        if(idx>=nums.size()){
            res.push_back(items);
            return;}

2. 先考虑包含nums[i]的分支，再考虑不含nums[i]的分支，其实掩盖了维护items的思想：由于我需要回溯，因此返回到上一层时，items应该回复上一步的样子，即items.pop_back();，而在上面的代码中，items.pop_back();干了两件事：1. 为右分支（不含nums[i]的分支）创造条件；2. 维护items数组以便维护。 这不是很直观，因此我调换了两个分支的顺序。

完整代码如下：

class Solution {
public:
	//先定义递归过程
    void subsets_builder(vector<int>& nums,vector<vector<int>>& res,vector<int>& items,int idx){
        if(idx>=nums.size()){
            res.push_back(items);
            return;}
        //不选择nums[idx]的分支
        subsets_builder(nums,res,items,idx+1);
		//选择nums[idx]的分支
        items.push_back(nums[idx]);
        subsets_builder(nums,res,items,idx+1);
        //由于items是传引用，因此要把items恢复到上一步的状态，这样才能“回溯”
        items.pop_back();
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res; //最后要返回的数组
        vector<int>items; //每次要push_back进res里的子集
        int idx = 0; //从0开始遍历nums数组的元素
        subsets_builder(nums,res,items,idx);
        return res;
    }
};

解法二：位运算

声明：图片来源：小象学院 点击进入原视频
首先复习一下C++里的位运算：

之前一直不太理解左移和右移，现在理解了一下：

以左移k位为例，相当于乘了k个2，二进制里乘k个2就是在后面加k个0（对比一下十进制里，乘k个10也是在后面加k个0）；

右移k位，就是把“小数点”往前移动k位，并舍弃小数点(向下取整)，比如0101>>2 = 01.01 = 0001（前面几个0不影响大小）

当然这个图的取反是有点小问题的，一个int型在PC上应该是32/64位，不可能只有四位数字的，因此3取反不可能是12这么小。

言归正传，这道题的思路：

假设nums里有{A,B,C}三个元素，这三个元素可以分别用001\010\100表示（每一个位表示某个元素是否能取到）。
众所周知，根据二项式定理，3个元素选取k个，一共有2^3=8种，正好是0b111+1表示的数字。
那么如下图所以，所有的可能性都可以用0b000和0b111之间的数字来表示：

和思路一一样，设置一个vector<int> items来表达当前的子集，vector<vector<int>> ret表示子集的集合。

i从0循环到7，j表示nums的下标，如果i和 1<<j（1左移j次，相当于乘了j个2）之间取与运算&为1，表示这个组合里包含第j个元素，则items.push_back(nums[j])，与第一问不一样的的是，每一层外层循环，items都被重新初始化一次。

完整代码如下：

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        int max_num = 1<<nums.size(); //相当于python里的2**nums.size()
        vector<vector<int>> ret;  //最终返回结果的数组
        for(int i=0;i<max_num;i++){
        vector<int> items;  // 保存子集的数组
            for(int j=0;j<nums.size();j++){
                if(i&(1<<j)){  // 如果按位与为真，说明i所代表的子集里有nums[j]这个元素
                    items.push_back(nums[j]);
                }
            }
        ret.push_back(items);
        }
    return ret;
    }
};

这可能也是二进制的魅力，在表达是/非的逻辑上，0和1两个数字足矣，而二项式定理正好也是2的n次幂，因此最高位的 111…1+1 就代表了一共有多少个组合数。

另外第一次写的时候，把按位与&符号写成了逻辑与&&符号，关于二者的区别可以参考：
C++中运算符 &和&&、|和|| 的区别