递归回溯法 解子集问题（包含重复元素、不包含重复元素）

问题1：所有子集（原数组中不包含重复元素）

给定一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

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

解题思路：

本题提供两种思路：递归回溯法和动态规划

//递归回溯

class Solution {
public:
vector<vector<int>> res;
    	vector<int> temp;
    void dfs(int i,vector<int>& nums)
    {
        //当遍历完数组的最后元素之后的元素时，说明已经全部遍历完了
        if(i==nums.size())
        {
            res.push_back(temp);
            return;
        }
        //选择当前元素
        temp.push_back(nums[i]);
        dfs(i+1,nums);
        //回溯
        temp.pop_back();
        //不选择当前元素
        dfs(i+1,nums);
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        dfs(0,nums);
        return res;
    }
    }
};

//动态规划

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res{vector<int>()};//定义一个二维的结果数组res，初始化一个空数组
        //遍历nums数组中的每一个元素
        for(int i=0;i<nums.size();i++)
        {
            int len=res.size();//计算当前res的长度，为了下面的遍历次数做准备
            //也就是要把当前res中的每个数组都加上新的元素，复制到新数组中，再从原数组中减去最后一个元素
            for(int j=0;j<len;j++)
            {
                res[j].push_back(nums[i]);//给之前的数组加上当前的数
                res.push_back(res[j]);//将res[j]数组拷贝到新数组
                res[j].pop_back();//将刚刚加的数从res[j]中删掉
            }
        }
        //返回结果res
        return res;
    }
}；

问题2：子集（包含重复元素）

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

解题思路：

1.首先，遇到需要去重的递归回溯问题，需要对数组进行排序

2.标记每个元素是否被使用过

3.遍历所有元素，只有当当前元素与前一个元素相同，并且前一个元素未被使用时，才需要去重 

源代码如下：

class Solution {
public:
    vector<int> temp;//临时数组
    vector<vector<int>> res;//结果数组
    void dfs(int start,vector<int>& nums,vector<bool>& used)
    {
        res.push_back(temp);//每次递归都将临时数组temp存放到res中
        for(int i=start;i<nums.size();i++)
        {
            //如果当前元素与前一个元素相同，并且前一个元素没有被使用过，那么就会存在出现重复子集
            //eg.[1,2,2]
            //当i=2时，如果前一个子集是[1],i=1的元素没有被使用，最终答案会出现两次[1,2]，因为i=1的元素也会被选一次
            //如果前一个子集是[1,2]，i=1的元素被使用过了，[1,2,2]不会重复出现在最终答案中
            if(i>0&&nums[i]==nums[i-1]&&!used[i-1]) continue;
            //选择当前元素
            temp.push_back(nums[i]);
            //标记当前元素已被使用
            used[i]=true;
            //递归地进行下一个
            dfs(i+1,nums,used);
           	//回溯
            used[i]=false;
            temp.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        res.clear();
        temp.clear();
        sort(nums.begin(),nums.end());//去重都需要对原数组进行排序
        vector<bool> used(nums.size(),false);//设置一个uesd数组，用来标记元素是否被使用
        dfs(0,nums,used);//递归
        return res;
    }
};