C++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
解释：
假设输入向量{5,2,9}

每一位对应输入向量当中的一个数值，通过移位遍历并通过按位置与得到相应的子集。

#include <iostream>
#include<vector>
using namespace std;
class Solution {
public:
    vector<int> t;
    vector<vector<int>> ans;

    vector<vector<int>> subsets(vector<int>& nums) {
        int n = nums.size();
        for (int mask = 0; mask < (1 << n); ++mask) {
            t.clear();
            for (int i = 0; i < n; ++i) {
                if (mask & (1 << i)) {
                    t.push_back(nums[i]);
                }
            }
            ans.push_back(t);
        }
        return ans;
    }
};

int main()
{
    vector<int> temp = { 1,2,3,4 };
    Solution kill;
    vector<vector<int>> result=kill.subsets(temp);
    int len2 = result.size();
    for (int i = 0; i < len2; ++i)
    {
        int len1 = result[i].size();
        for (int j = 0; j < len1; ++j)
        {
            cout << result[i][j] << ' ';
        }
        cout << endl;
    }
    return 0;
}

1
2
1 2
3
1 3
2 3
1 2 3
4
1 4
2 4
1 2 4
3 4
1 3 4
2 3 4
1 2 3 4

第二种用递归的方式（感觉按照运算for或if的逻辑来理解挺烧脑）：
因为每一位都有两种状态，要么被取，要么没有被取，然后在迭代dfs函数当中设置两种状态，取和不取。取就将存入，不取就弹出。
代码结构：

vector<int> t;
void dfs(int cur, int n) {
    if (cur == n) {
        // 记录答案
        // ...
        return;
    }
    // 考虑选择当前位置
    t.push_back(cur);
    dfs(cur + 1, n, k);
    t.pop_back();
    // 考虑不选择当前位置
    dfs(cur + 1, n, k);
}

class Solution {
public:
    vector<int> t;
    vector<vector<int>> ans;

    void dfs(int cur, vector<int>& nums) {
        if (cur == nums.size()) {//到最后位置，停止
            ans.push_back(t);
            return;
        }
        t.push_back(nums[cur]);//取当前位置
        dfs(cur + 1, nums);
        t.pop_back();//不取当前位置
        dfs(cur + 1, nums);
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(0, nums);
        return ans;
    }
};