回溯 子集问题

子集问题的特征相当于求遍所有的叶子节点，所以与前边的组合问题，分割问题，都可以抽象为收集树的节点的问题，
区别是子集是求所有的叶子节点；

leetcode 78

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

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

示例 1：

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

输入：nums = [0]
输出：[[],[0]]

思路

依然考虑的是用回溯三部曲来分析这道题

参数与返回值

由于本题是求解所有的叶子节点，所以可以考虑不写终止条件，因为给的数组是有限的数组,但是还是需要设
全局变量result,与记录到的单个叶子节点的path，还有一个就是记录初始位置的startIndex,只有当startIndex大于数组
的长度的时候，遍历才会终止，转换为代码如下：

if(startIndex >= nums.size())
{
    return;
}

递归函数与终止条件

终止条件如上所述。

void backtracking(vector<int>& nums,int startIndex)

单层遍历与回溯

因为可以不考虑终止条件，所以逻辑上相当于直接遍历整棵树

 for(int i = startIndex;i < nums.size();i++)
       {
           path.push_back(nums[i]); //子集收集元素
           backtracking(nums,i+1); //注意从i+1开始，不重复取元素
           path.pop_back();
       }

完整代码

class Solution {
private:
   vector<vector<int>> result;//存储所有的结果
   vector<int> path;
   void backtracking(vector<int>& nums,int startIndex)
   {
       result.push_back(path);//收集子集，要放在终止条件的上面，否则会遗漏掉元素
       if(startIndex >= nums.size())
       {
           return;
       }
       for(int i = startIndex;i < nums.size();i++)
       {
           path.push_back(nums[i]); //子集收集元素
           backtracking(nums,i+1); //注意从i+1开始，不重复取元素
           path.pop_back();
       }
   }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
      result.clear();
      path.clear();
      backtracking(nums,0);
      return result;
    }
};

leetcode 90

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

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

示例 1：

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

输入：nums = [0]
输出：[[],[0]]

思路

本题就在上边的题目的基础上，多了个不包含重复元素，其实就多了一个
去重的问题。

for (int i= startIndex;i < nums.size();i++)
        {
            if(i > 0 && nums[i] == nums[i-1] && used[i-1] == false)
            {//如果used[i-1]==true,说明同一树枝使用过candidates[i-1]
             //如果used[i-1]==false,说明同一树枝使用过candidates[i-1]
             //而我们要跳过同一树层使用过的元素
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums,i+1,used);
            used[i] = false;
            path.pop_back();

完整代码

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex,vector<bool>& used)
    {
        result.push_back(path);
        for (int i= startIndex;i < nums.size();i++)
        {
            if(i > 0 && nums[i] == nums[i-1] && used[i-1] == false)
            {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums,i+1,used);
            used[i] = false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
      result.clear();
      path.clear();
      vector<bool> used(nums.size(),false);
      sort(nums.begin(),nums.end()); //去重排序
      backtracking(nums,0,used);
      return result;
    }
};