1. 题目来源

链接：子集
来源：LeetCode

2. 题目说明

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

说明：

解集不能包含重复的子集。

示例1：

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

3. 题目解析

方法一：位运算解法，被秀到头皮发麻

数组 [1,2,3] 的子集也就是其中的三个元素取与不取的组合。把它想象为二进制的三个 bit 位 1 1 1，那么从 0 0 0 到 1 1 1 的 8 个数，就构成了所有子集的选取情况。比如 0 0 1 表示取第1个元素，0 1 1 表示取前两个元素。

详述如下：

把数组中所有的数分配一个状态，true 表示这个数在子集中出现，false 表示在子集中不出现，那么对于一个长度为n的数组，每个数字都有出现与不出现两种情况，所以共有 $2^n$ 中情况，那么我们把每种情况都转换出来就是子集了，我们还是用题目中的例子, [1 2 3] 这个数组共有8个子集，每个子集的序号的二进制表示，把是1的位对应原数组中的数字取出来就是一个子集，八种情况都取出来就是所有的子集了，参见代码如下：

详解位运算版本：

class Solution {
    
public:
    vector<vector<int> > subsets(vector<int> &S) {
    
        vector<vector<int> > res;
        sort(S.begin(), S.end());
        int max = 1 << S.size();
        for (int k = 0; k < max; ++k) {
    
            vector<int> out = convertIntToSet(S, k);
            res.push_back(out);
        }
        return res;
    }
    vector<int> convertIntToSet(vector<int> &S, int k) {
    
        vector<int> sub;
        int idx = 0;
        for (int i = k; i > 0; i >>= 1) {
    
            if ((i & 1) == 1) {
    
                sub.push_back(S[idx]);
            }
            ++idx;
        }
        return sub;
    }
};

简洁一点的位运算版本：

class Solution {
    
public:
    vector<vector<int>> subsets(vector<int>& nums) {
    
        vector<vector<int>> ret;
        ret.push_back({
    });
        int size = nums.size();
        int subsize = pow(2, size);
        int hash = 1;
        while (hash < subsize) {
    
            vector<int> temp;
            for (int k = 0; k < size; ++k) {
    
                int a = 1 << k;
                if (a & hash) {
    
                    temp.push_back(nums[k]);
                }
            }
            ret.push_back(temp);
            ++hash;
        }
        return ret;
    }
};

极为简洁的位运算版本：

class Solution {
    
public:
    vector<vector<int>> subsets(vector<int>& nums) {
    
        int S = nums.size();
        int N = 1 << S;
        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]);
            res.push_back(v);
        }
        return res;
    }
};

在子集2中，子集存在重复元素后，位运算方法不适用于此了。

方法二：非递归解法，思路简单易得，需要避开一些坑点即可

这道求子集合的问题，由于其要列出所有结果，按照以往的经验，肯定要是要用递归来做。这道题其实它的非递归解法相对来说更简单一点，下面先来看非递归的解法思路：

最开始在想的时，是想按照子集的长度由少到多全部写出来，比如子集长度为0的就是空集，空集是任何集合的子集，满足条件，直接加入。下面长度为1的子集，直接一个循环加入所有数字，子集长度为2的话可以用两个循环，但是这种想法到后面就行不通了，因为循环的个数不能无限的增长，所以必须换一种思路。

可以一位一位的往上叠加，比如对于题目中给的例子 [1,2,3] 来说，最开始是空集，那么现在要处理1，就在空集上加1，为 [1]，现在有两个自己 [] 和 [1]，下面来处理2，在之前的子集基础上，每个都加个2，可以分别得到 [2]，[1, 2]，那么现在所有的子集合为 [], [1], [2], [1, 2]，同理处理3的情况可得 [3], [1, 3], [2, 3], [1, 2, 3], 再加上之前的子集就是所有的子集合了，代码如下：

class Solution {
    
public:
    vector<vector<int> > subsets(vector<int> &S) {
    
        vector<vector<int> > res(1);
        for (int i = 0; i < S.size(); ++i) {
    
            int size = res.size();
            for (int j = 0; j < size; ++j) {
    
                res.push_back(res[j]);
                res.back().push_back(S[i]);
            }
        }
        return res;
    }
};

方法三：递归解法

递归的解法，相当于一种深度优先搜索，由于原集合每一个数字只有两种状态，要么存在，要么不存在，那么在构造子集时就有选择和不选择两种情况，所以可以构造一棵二叉树，左子树表示选择该层处理的节点，右子树表示不选择，最终的叶节点就是所有子集合，树的结构如下：

                        []                    处理1
                   /          \        
                  /            \     
                 /              \
              [1]                []           处理2
           /       \           /    \
          /         \         /      \        
       [1 2]       [1]       [2]     []       处理3
      /     \     /   \     /   \    / \
  [1 2 3] [1 2] [1 3] [1] [2 3] [2] [3] []

class Solution {
    
public:
    vector<vector<int> > subsets(vector<int> &S) {
    
        vector<vector<int> > res;
        vector<int> out;
        getSubsets(S, 0, out, res);
        return res;
    }
    void getSubsets(vector<int> &S, int pos, vector<int> &out, vector<vector<int> > &res) {
    
        res.push_back(out);
        for (int i = pos; i < S.size(); ++i) {
    
            out.push_back(S[i]);
            getSubsets(S, i + 1, out, res);
            out.pop_back();
        }
    }
};

也是基于上述思想的dfs写法，击败100%用户，效率高于上述代码：

class Solution {
    
private:
    vector<vector<int> >res;
public:
    vector<vector<int> > subsets(vector<int> &S) {
    
        res.clear();
        vector<int>tmpres;
        dfs(S, 0, tmpres);
        return res;
    }
    void dfs(vector<int> &S, int iend, vector<int> &tmpres)
    {
    
        if(iend == S.size())
            {
    res.push_back(tmpres); return;}
        //选择S[iend]
        tmpres.push_back(S[iend]);
        dfs(S, iend+1, tmpres);
        tmpres.pop_back();
        //不选择S[iend]
        dfs(S, iend+1, tmpres);
    }
};