LeetCode/solutions/90. Subsets II.md

# [90. Subsets II](https://leetcode.com/problems/subsets-ii/)
# 思路
这题就是[78. Subsets](https://leetcode.com/problems/subsets/)的升级版，做法也和此题类似，可参考之前[78. Subsets题解](https://github.com/ShusenTang/LeetCode/blob/master/solutions/78.%20Subsets.md)。
为了使相同的元素都是挨着的，我们首先需要对nums进行排序。
## 思路一、DFS
构造一棵二叉树，左子树表示选择该层处理的节点，右子树表示不选择，最终的叶节点就是所有子集合，以[1,2,2]为例，树的结构如下：

```
                        []        
                   /          \        
                  /            \     
                 /              \
              [1]                []
           /       \           /    \
          /         \         /      \        
       [1 2]       [1]       [2]     []
      /     \     /   \     /   \    / \
  [1 2 2] [1 2]  X   [1]  [2 2] [2] X  []
```
需要注意去掉重复值，即对树进行剪枝: 当前一层的元素（`nums[level-1]`）未被访问且`nums[level]==nums[level-1]`时，当前元素`nums[level]`也不应该访问，即只沿右子树下降。
## 思路二
此题也可以使用迭代的方式来完成此题。
参考[78. Subsets题解](https://github.com/ShusenTang/LeetCode/blob/master/solutions/78.%20Subsets.md)，当处理到第一个2时，此时的子集合为[], [1], [2], [1, 2]，
而这时再处理第二个2时，如果在[]和[1]后直接加2会产生重复，所以只能在上一个循环生成的后两个子集合后面加2。
所以我们用last来记录上一个处理的数字，然后判定当前的数字和上面的是否相同，若不同，则循环还是从0到当前子集的个数，若相同，
则新子集个数减去之前循环时子集的个数当做起点来循环，这样就不会产生重复了。


# C++
## 思路一
### 好理解版
``` C++
class Solution {
private:
    void DFS(vector<vector<int>>&res, vector<int>&subset, vector<bool>&visited, const vector<int>& nums, int level){
        if(level == nums.size()) { // 叶节点
            res.push_back(subset);
            return;
        }
        
        if(level > 0 && nums[level] == nums[level - 1] && !visited[level - 1]){
            DFS(res, subset, visited, nums, level + 1); // 沿右子树下降
            return;
        }
        
        // 沿左子树下降
        visited[level] = true;
        subset.push_back(nums[level]);
        DFS(res, subset, visited, nums, level + 1);
        visited[level] = false;
        subset.pop_back();
        // 沿右子树下降
        DFS(res, subset, visited, nums, level + 1);
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>>res;
        vector<int>subset;
        vector<bool>visited(nums.size(), false);
        sort(nums.begin(), nums.end());
        DFS(res, subset, visited, nums, 0);
        return res;
    }
};
```
### 简洁版
``` C++
class Solution {
void DFS(vector<vector<int>> &res, int level, vector<int> &subset, vector<int> &nums) {
        res.push_back(subset);
        for (int i = level; i < nums.size(); ++i) {
            subset.push_back(nums[i]);
            DFS(res, i + 1, subset, nums);
            subset.pop_back();
            while (i + 1 < nums.size() && nums[i] == nums[i + 1]) ++i;
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>>res;
        vector<int>subset;
        vector<bool>visited(nums.size(), false);
        sort(nums.begin(), nums.end());
        DFS(res, 0, subset, nums);
        return res;
    }
};
```
## 思路二
``` C++
class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int> &nums) {
        vector<vector<int>>res;
        res.push_back(vector<int>{});
        sort(nums.begin(), nums.end());
        int last = nums[0], size = 1;
        for(int i = 0; i < nums.size(); i++){
            if(last != nums[i]){
                last = nums[i];
                size = res.size();
            }
            int newSize = res.size();
            for (int j = newSize - size; j < newSize; ++j) {
                res.push_back(res[j]);
                res.back().push_back(nums[i]);
            }
        }
        return res;
    }
};
```