[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;
    }
};

---

2025年02月07日22:12:05
其实 y 总上面的枚举方式已经很清楚了，每一个元素可能出现的次数是 0~C1 次。那就去枚举这个元素出现的次数就好了。按元素枚举的话，就完全不需要管是否重复的问题。能看到这也是 y 总为啥代码里面缺少了去重这块逻辑的原因。

选 或 不选
去重方式一：更好理解点，也好写。

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

        auto dfs = [&](this auto &&dfs, int u) {
            if (u == n) {
                res.push_back(path);
                return ;
            }

            path.push_back(nums[u]);
            dfs(u + 1);
            path.pop_back();

			// 选在前，不选在后。不选时，后面的相同元素也不应该被选。
            while (u + 1 < n && nums[u] == nums[u + 1]) u ++ ;
            dfs(u + 1);
        };

        dfs(0);
        return res;
    }
};

去重方式二：

这个去重方式也不难想吧，就如果当前选的元素的前一个元素跟我一样，且前一个元素还没被选的话，那么我肯定也不能被选。保证元素顺序的稳定性。

但这里就涉及到了一个问题：例如：【1,1,2,2】这个用例。在第一个 1 不选的情况下，当 dfs 到了第二 1 的时候，就直接 return 了？？那么后续的 第一个 2 选的情况下，就被直接剪枝了，肯定是不合适的。

即，这里的 if 判断实际上只是判断当前第二 1 不能被选择。要保留后续的 2 选/不选 的分支情况。所以单独再加上一个 dfs(u+1)。

这个一开始都搞错了，想了想是这样写。但是看着就很冗余。

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

       auto dfs = [&](this auto &&dfs, int u, int idx) {
           if (path.size() == u) {
               res.push_back(path);
               return ;
           }

           if (idx == n) return ;
           // 注意这里不能直接 return，否则缺少元素
           if (idx > 0 && st[idx - 1] == false && nums[idx] == nums[idx - 1]) {
               dfs(u, idx + 1);
               return ;
           }

           path.push_back(nums[idx]);
           st[idx] = true;
           dfs(u, idx + 1);
           path.pop_back();
           st[idx] = false;


           dfs(u, idx + 1);
       };

       for (int i = 0; i <= n; i ++ ) {
           dfs(i, 0);
       }

       return res;
   }
};