leetCode 90.子集 II + 回溯算法 + 图解 + 笔记

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

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

示例 1：

cpp 复制代码

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

示例 2：

cpp 复制代码

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

本题其实就是子集（leetCode 78.子集 + 回溯算法 + 图解 + 笔记）和组合总和 II （leetCode 40.组合总和 II + 回溯算法 + 剪枝 + used数组 + 图解）这两道题目的一个完美结合

>>问题思考(O_O)?

1).什么是**"去重"**？

"去重" ：就是使用过 的元素不能重复选取了

2).何为**"树枝去重"** 、"树层去重"？（代码随想录Carl老师自创的名词）

可把组合问题抽象为树形结构 ，used（"使用过"） 在这个树形结构上是有两个维度的 ，一个维度表示是同一树枝上使用过 ，一个维度表示是同一树层上使用过

来看题目要求："集合（数组nums）有重复元素 ，但还不能有重复的组合 "。

例如{1,2,2}，仅仅是两个元素的数值相同，并没有重复使用同一个元素。那分别是不同的两个元素，那它就是合法的，所以说树枝上前面取了2，后面我还能不能取2呢？可以的，因为它仅仅是你这两个元素数值都是2而已，但其实取的是两个不同的元素。所以说树枝上取了重复数值的元素（是两个不同的元素）可不可以？可以的，没问题(o´ω`o)و

但我树层上能不能取重复数值的元素呢？因为树层上你前面取2，后面取2，你得到的子集，它注定就是重复的。所以说树层上相邻两个元素（数值相同）重复选取的话，它得到的子集就是重复的子集。

故去重的是同一树层上的"使用过"是不同组合里的元素，而对于同一树枝上的都是一个组合里的元素，不用去重。
强调注意：在树层去重时，需要对数组排序

（3）收获结果

子集问题 、组合问题 、分割问题 都可以抽象成一棵树，不同的是：

组合问题和分割问题都是收集树形结构中的叶子节点的结果
子集问题收集树形结构中的所有节点的结果

>>回溯三部曲:

1).确定回溯函数参数

path来收集符合条件的结果
result 保存 path,作为结果集
startIndex来控制for循环的起始位置
used 是bool型数组，用来记录同一树枝上的元素是否使用过

cpp 复制代码

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums,vector<bool>& used,int startIndex)

2).递归的终止条件（本题可以不写）

cpp 复制代码

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

3).单层搜索的逻辑

去重逻辑 ：if( i>0 && nums[i] == nums[i - 1] && used[i - 1] == false)，表示前一个树枝，使用了nums[i - 1] ，也就是说同一树层使用过nums[i - 1] 。那么此时 for 循环里通过 continue 操作跳过此种情况的递归

cpp 复制代码

for(int i=startIndex;i<nums.size();i++) {
    if(i>0 && nums[i]==nums[i-1] && used[i-1]==false) {
        continue;
    }
    ......
}

思考(O_O)? 为啥used[i-1] == false 能表示同一树层 nums[i-1] 使用过这种情况呢？

是因为在同一树层 ，used[i-1] == false 能表示当前取的nums[i] 是从nums[i-1] 回溯而来的。used[i]==true, 表示进入下一层递归 ，取下一个数 ，所以在树枝上

C++代码：

cpp 复制代码

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

时间复杂度: O(n * 2^n)
空间复杂度: O(n)