子集 - leetcode

题目描述

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

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

示例:

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subsets

一、递归方案

看到这道题，第一个想到的方案就是遍历子集个数 k 由 0 到 nums.size() 个，依次把个数为 k 的子集添加进去，即

1. k = 0，寻找元素个数为0的子集；
2. k = 1，寻找元素个数为1的子集；
3. k = 2，寻找元素个数为2的子集；
4. …
5. k = nums.size()，寻找元素个数为nums.size()的子集；

此时需要编写一个递归函数用于寻找个数为k的子集，并添加到目标容器中，即

void dfs(int k, int start, vector<int>& nums, vector<int>& temp, vector<vector<int>>& res) {
    if(temp.size() == k) {
        res.push_back(temp);
        return;
    }
    for(int i = start; i <= nums.size()-k+temp.size(); i++) {
        temp.push_back(nums[i]);
        dfs(k, i+1, nums, temp, res);
        temp.pop_back();
    }
}

然后就是一个for循环遍历k，在循环里面执行dfs函数

vector<vector<int>> subsets(vector<int>& nums) {
    vector<int> temp;
    vector<vector<int>> res;
    for(int k = 0; k <= nums.size(); k++) {
        temp.clear();
        dfs(k, 0, nums, temp, res);
    }
    return res;
}

总体代码

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

上面的方案是递归，在看题解区时看到很多用位运算来做的，具体思路是这样的。

二、位运算方案

因为对于数组nums里的每一个数，都有选或不选2种可能，所以总共有2的nums.size()次方个子集，比如，对于样例而言，一共有2^3 = 8个子集，自己情况如下

首先，需要先确定总共有多少情况，使用位运算 N = 1 << nums.size()，即实现2次幂运算

然后遍历 i 从 0 到 N - 1 ，对于每一次遍历，里面必须再遍历nums数组，

查看nums的每一位是否要进入vector中

实现方式就是使用位运算

设用 j 来遍历nums，对于确定第 j 位是否在vector中

依据上面的表格可以看出，表格中的3位二进制表示的就是 i ，而后面的vector中要不要加入第 j 位需要看 j 的值，即需要让第 j 位表示的二进制数与 i 的二进制数进行按位与，如果为0，表明不能入vector。

示例分析

以上述表格为例，分析过程：
j 从 0 到 2 ，表示的二进制数分别为 001，010，100

1. i = 0，此时 i 的二进制表示为 0 0 0，，表示的无论 j 为什么，按位与都为 0， vector为[]；
2. i = 1，此时 i 的二进制表示为 0 0 1，
   1. j = 0，001 与 001 按位与，结果为1，所以nums[0]进入vector
   2. j = 1，001 与 010 按位与，结果为0，所以nums[1]不进入vector
   3. j = 2，001 与 100 按位与，结果为0，所以nums[2]不进入vector
   4. 所以vector最终为 [1]
3. i = 2，此时 i 的二进制表示为 0 1 0，
   1. j = 0，010 与 001 按位与，结果为1，所以nums[0]不进入vector
   2. j = 1，010 与 010 按位与，结果为0，所以nums[1]进入vector
   3. j = 2，010 与 100 按位与，结果为0，所以nums[2]不进入vector
   4. 所以vector最终为 [2]
4. i = 3，此时 i 的二进制表示为 0 1 1，
   1. j = 0，011 与 001 按位与，结果为1，所以nums[0]进入vector
   2. j = 1，011 与 010 按位与，结果为0，所以nums[1]进入vector
   3. j = 2，011 与 100 按位与，结果为0，所以nums[2]不进入vector
   4. 所以vector最终为 [1 2]
5. i = 4，此时 i 的二进制表示为 1 0 0，
   1. j = 0，100 与 001 按位与，结果为1，所以nums[0]不进入vector
   2. j = 1，100 与 010 按位与，结果为0，所以nums[1]不进入vector
   3. j = 2，100 与 100 按位与，结果为0，所以nums[2]进入vector
   4. 所以vector最终为 [3]
6. i = 5，此时 i 的二进制表示为 1 0 1，
   1. j = 0，101 与 001 按位与，结果为1，所以nums[0]进入vector
   2. j = 1，101 与 010 按位与，结果为0，所以nums[1]不进入vector
   3. j = 2，101 与 100 按位与，结果为0，所以nums[2]进入vector
   4. 所以vector最终为 [1 3]
7. i = 6，此时 i 的二进制表示为 1 1 0，
   1. j = 0，110 与 001 按位与，结果为1，所以nums[0]不进入vector
   2. j = 1，110 与 010 按位与，结果为0，所以nums[1]进入vector
   3. j = 2，110 与 100 按位与，结果为0，所以nums[2]进入vector
   4. 所以vector最终为 [2 3]
8. i = 7，此时 i 的二进制表示为 1 1 1，
   1. j = 0，111 与 001 按位与，结果为1，所以nums[0]进入vector
   2. j = 1，111 与 010 按位与，结果为0，所以nums[1]进入vector
   3. j = 2，111 与 100 按位与，结果为0，所以nums[2]进入vector
   4. 所以vector最终为 [1 2 3]

最终代码

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        int S = nums.size();
        int N = 1 << S;//2次幂运算
        
        vector<vector<int> > res;
        for (int i = 0; i < N; ++i) {
            vector<int> v;
            for (int j = 0; j < S; ++j)
                if (i & (1 << j))			//这里就是最主要的地方，实现按位与运算，
                    v.push_back(nums[j]);	//判断nums[j]是否应该进入vector中
            res.push_back(v);
        }
        return res;
    }
};