[Mdfs] lc90. 子集 II(组合类型枚举+多重背包+去重经典)

1. 题目来源

链接：90. 子集 II

必看，必刷，dfs 经典：

• [Mdfs] lc39. 组合总和(dfs+经典)
• [Mdfs] lc40. 组合总和 II(dfs+经典)
• [Mdfs] lc46. 全排列(dfs+经典)
• [Mdfs] lc47. 全排列 II(dfs搜索顺序+去重处理+知识理解+经典)
• [Mdfs] lc77. 组合(组合类型枚举+题目总结+经典)
• [Mdfs] lc78. 子集(二进制枚举+排列类型枚举+经典)
• [Mdfs] lc90. 子集 II(组合类型枚举+多重背包+去重经典)

---

2. 题目解析

排列类型枚举+去重。

方法一：

• 直接暴力枚举，和 [Mdfs] lc78. 子集(二进制枚举+排列类型枚举+经典) 一样，得到方案后排序，放入 set 去重即可。很无脑的做法。

方法二：

• 依旧是 选、不选， 排序过后，人为定序。如果当前元素和上个元素相同，且上个元素没被选的时候，则这种方案作废，直接 return ; 即可。

方法三：

• 实际上和多重背包差不多，每个数就是物品，次数即为物品的数量限制。
• 那么问题转化为每个数选 0~ci 次最后得到的 方案数。
• 其实是个乘法原理的过程。
• 注意需要恢复现场。这种恢复现场是需要可以先不看 dfs，本层是没有 cnt[i]+1 个 u 的，加入进来了这么多个，那么走的时候就要删除掉，恢复成原来的样子就行了。
• dfs 代码有点细节。是先 dfs，然后再加入，等价于选 0 个，下一次才是选 1 个…这个和平常的有所出入，但对应在本题是非常适合的。
• 排序可以做，统计相同数字出现次数即可。
• 哈希表也可以做，直接枚举每个数选的个数就行了。

---

时间复杂度：$O(n{2}^n)$

空间复杂度：$O(n)$

---

代码：

方法一：

暴力判重。

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        set<vector<int>> S;
        vector<vector<int>> res;
        int n = nums.size();
        for (int i = 0; i < 1 << n; i ++ ) {
            vector<int> path;
            for (int j = 0; j < n; j ++ )
                if (i >> j & 1)
                    path.push_back(nums[j]);
                    
            sort(path.begin(), path.end());
            S.insert(path);
        }

        for (auto s : S) res.push_back(s);

        return res;
    }
};

也可以直接在外面排序，保证枚举顺序就是有序的，这样时间效率就大大提高了。

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        set<vector<int>> S;
        vector<vector<int>> res;
        int n = nums.size();
        sort(nums.begin(), nums.end());
        for (int i = 0; i < 1 << n; i ++ ) {
            vector<int> path;
            for (int j = 0; j < n; j ++ )
                if (i >> j & 1)
                    path.push_back(nums[j]);
            S.insert(path);
        }

        for (auto s : S) res.push_back(s);

        return res;
    }
};

---

方法二：

选、不选递归排列类型枚举+人为定序即可，和枚举组合问题差不多。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<bool> st;

    void dfs(int u, vector<int>& a) {
        if (u == a.size()) {
            res.push_back(path);
            return ;
        }

        // 不选 u
        dfs(u + 1, a);

        // 选 u，但如果 a[u-1]==a[u]，且a[u-1]没选的话，则a[u]也不能选
        if (u && a[u - 1] == a[u] && !st[u - 1]) return ;
        st[u] = true;
        path.push_back(a[u]);
        dfs(u + 1, a);
        path.pop_back();
        st[u] = false;
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        st.resize(n);

        dfs(0, nums);

        return res;
    }
};

选不选，二进制枚举实现方式。

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();

        vector<vector<int>> res;

        for (int i = 0; i < 1 << n; i ++ ) {
            bool flag = true;                   // 放里面来...针对每种枚举，都需要判断
            vector<int> path;
            for (int j = 0; j < n; j ++ ) {
                if (i >> j & 1) {
                    if (j && !(i >> j - 1 & 1) && nums[j - 1] == nums[j]) {
                        flag = false;
                        break;
                    }
                    path.push_back(nums[j]);
                }
            }

            if (flag) res.push_back(path);
        }

        return res;
    }
};

---

理解成多重背包，枚举每个数选的次数。

哈希+dfs。

class Solution {
public:
    unordered_map<int, int> cnt;
    vector<vector<int>> res;
    vector<int> path;

    void dfs(int u) {
        if (u > 10) {
            res.push_back(path);
            return ;
        } 

        // 每个数有 0,1,2,..,cnt[u] 总共 cnt[u]+1 种选法
        for (int i = 0; i < cnt[u] + 1; i ++ ) {
            // 注意dfs顺序，首先是选0个，就不加了，直接dfs下一层。第i次循环代表u被选了i个，选0个的情况就被包含了
            dfs(u + 1);     
            path.push_back(u);
        }

        // 恢复现场。可以先不看这个dfs造成的影响。之前没有加，现在加了，那就全部弹出就行了
        for (int i = 0; i < cnt[u] + 1; i ++ ) path.pop_back();
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        for (int &c : nums) cnt[c] ++ ;
        dfs(-10);               // 暴力枚举所有数即可，数的范围从 -10~10

        return res;
    }
};

排序+dfs

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;

    void dfs(int u, vector<int>& nums) {
        if (u == nums.size()) {
            res.push_back(path);
            return ;
        }
        int k = u + 1;
        while (k < nums.size() && nums[k] == nums[u])  k ++ ;
        for (int i = u; i <= k; i ++ ) {
            dfs(k, nums);
            path.push_back(nums[u]);
        }
        for (int i = u; i <= k; i ++ ) path.pop_back();
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        dfs(0, nums);
        return res;
    }
};