LintCode-17: Subset 和 Subset II (搜索题中的超级经典！）

置顶纸上得来终觉浅绝知此事要躬行

已于 2023-12-11 03:18:55 修改

阅读量982

点赞数

分类专栏： algorithm-design 文章标签： LintCode

于 2018-06-21 16:05:31 首次发布

本文链接：https://blog.csdn.net/roufoo/article/details/80761990

版权

algorithm-design 专栏收录该内容

818 篇文章 2 订阅

订阅专栏

Subsets

Given a set of distinct integers, return all possible subsets.

Example
Example 1:

Input: [0]
Output:
[
[],
[0]
]
Example 2:

Input: [1,2,3]
Output:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]
Challenge
Can you do it in both recursively and iteratively?

Notice
Elements in a subset must be in non-descending order.
The solution set must not contain duplicate subsets.

SubSet 这题有4种解法，其中DFS两种，BFS一种，位运算一种。
解法1：DFS组合类模板。对应每个元素都有选或不选两种可能。
输入为[1,2,3]的递归树如下图。注意，最下面一行的每个节点均为一个可行解。
在这里插入图片描述

class Solution {
public:
    /**
     * @param nums: A set of numbers
     * @return: A list of lists
     */
    vector<vector<int>> subsets(vector<int> &nums) {
        int n = nums.size();
        if (n == 0) return {{}};
        vector<vector<int>> result;
        vector<int> sol;
        sort(nums.begin(), nums.end());
        helper(nums, 0, result, sol);
        return result;
    }

private:
    void helper(vector<int> & nums, int pos, vector<vector<int>> &result, vector<int> & sol) {
        if (pos == nums.size()) {
            result.push_back(sol);
            return;
        }
        
        sol.push_back(nums[pos]);
        helper(nums, pos + 1, result, sol);
        sol.pop_back();
        helper(nums, pos + 1, result, sol);
        
        return;
    }
};

解法2：
DFS 通用回溯解法。注意！上面那个DFS没有for loop，这里的DFS有for loop!
注意:

是每次进入helper()的sol都是一个解，所以不用等到index=nums.size()再存到results里面。
vector < vector < int> > results;
results的值会是[]。如果想让它变成[[]]，要用results.push_back(vector());
输入为[1,2,3]的递归树如下图。注意：其中每个节点均为一个可行解。
由此看来，解法2只调用了DFS8次，而解法1调用了DFS15次。

class Solution {
public:
    /**
     * @param nums: A set of numbers
     * @return: A list of lists
     */
    vector<vector<int>> subsets(vector<int> &nums) {
        vector<vector<int> > results;
        vector<int> sol;
        
        if (nums.empty()) {
          results.push_back(vector<int>());
          return results;
        }
        
        sort(nums.begin(), nums.end());

        helper(nums, 0, sol, results);
        return results;
    }
    
    void helper(vector<int> &nums, int index, vector<int>&sol, vector<vector<int>> &results) {
        
        results.push_back(sol);
        for (int i=index; i<nums.size(); ++i) {
            sol.push_back(nums[i]);
            helper(nums, i+1, sol, results);    //切记这里是i+1，不是index+1
            sol.pop_back();
        }
    }

};

个人的一个总结:
1. 如果有重复元素，subsets和permutation都需要先排序。
2. 如果没有重复元素, permuation不需要先排序。subsets如果输出结果的每个subset不需要按字典序排序(也就是说(3,0,4)而不是(0,3,4)可以接受）的话，也不需要sort。否则如果输出结果的每个subset需要按字典序排序，那subsets这题就需要先排序。

二刷：

class Solution {
public:
    /**
     * @param nums: A set of numbers
     * @return: A list of lists
     *          we will sort your return value in output
     */
    vector<vector<int>> subsets(vector<int> &nums) {
        vector<vector<int>> res;
        int numsSize = nums.size();
        if (numsSize == 0) return {{}};
        sort(nums.begin(), nums.end());
        vector<int> sol;
        dfs(nums, 0, sol, res);
        return res;
    }
private:
    void dfs(vector<int> &nums, int startIndex, vector<int> &sol, vector<vector<int>> &res) {
        res.push_back(sol); 
        int numsSize = nums.size();
        for (int i = startIndex; i < numsSize; i++) {
            sol.push_back(nums[i]);
            dfs(nums, i + 1, sol, res);
            sol.pop_back();
        }
    }
};

解法3：BFS解法：
用 BFS 来解决该问题时，层级关系如下：
第一层: []
第二层: [1] [2] [3]
第三层: [1, 2] [1, 3], [2, 3]
第四层: [1, 2, 3]
每一层的节点都是上一层的节点拓展而来。
注意：

BFS的方法不需要sort。
一开始queue里要push空集{}。
代码如下：

class Solution {
public:
    /**
     * @param nums: A set of numbers
     * @return: A list of lists
     */
    vector<vector<int>> subsets(vector<int> &nums) {
        vector<vector<int>> vv;
        int n = nums.size();

        queue<vector<int>> q;
        q.push({});  //push {}
        
        while(!q.empty()) {
            vector<int> v = q.front();
            q.pop();
            vv.push_back(v);
            
            for (int i = 0; i < n; ++i) {
                if (v.size() == 0 || v.back() < nums[i]) {
                    vector<int> v2 = v;
                    v2.push_back(nums[i]);
                    q.push(v2);
                }
            }
        }
        
        return vv;
    }
};

二刷

class Solution {
public:
    /**
     * @param nums: A set of numbers
     * @return: A list of lists
     */
    vector<vector<int>> subsets(vector<int> &nums) {
        vector<vector<int>> vv;
        int n = nums.size();

        queue<vector<int>> q;
        q.push({});  //push {}
        
        while(!q.empty()) {
            vector<int> v = q.front();
            q.pop();
            vv.push_back(v);
            
            for (int i = 0; i < n; ++i) {
                if (v.size() == 0 || v.back() < nums[i]) {
                    v.push_back(nums[i]);
                    q.push(v);
                    v.pop_back();
                }
            }
        }
        
        return vv;
    }
};

解法4：位运算

    vector<vector<int>> subsets(vector<int> &nums) {
        vector<vector<int> > solution;
        vector<int> singleSol;
        int numSize=nums.size();
        int totalNum=pow(2,numSize)-1;
        solution.push_back(singleSol);
        
        for (int i=1; i<=totalNum; ++i) {
            singleSol.clear();
            for(int j=0; j<numSize; ++j) {
                int bitNum = (i>>j)&0x1;
                if (bitNum==1) {
                    singleSol.push_back(nums[j]);
                }
                sort(singleSol.begin(), singleSol.end());
            }

            solution.push_back(singleSol);
        }
        return solution;
    }

效率可能还要改进一下。

另外2种下次写。

另外分析一下算法复杂度。关于DFS的时间复杂度是O(答案个数×构造每个答案时间）。所以以上DFS的时间复杂度都是O(n*2^n)。

===============================
18. Subsets II

Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power set).

Example
Example 1:

Input: [0]
Output:
[
[],
[0]
]
Example 2:

Input: [1,2,2]
Output:
[
[2],
[1],
[1,2,2],
[2,2],
[1,2],
[]
]
Challenge
Can you do it in both recursively and iteratively?

Notice
Each element in a subset must be in non-descending order.
The ordering between two subsets is free.
The solution set must not contain duplicate subsets.

SubSet II 和SubSet类似，但是要注意去重。
以通用回溯解法为例：

   vector<vector<int>> subsetsWithDup(vector<int> &nums) {
        vector<vector<int>> results;
        vector<int> sol;
         
        if (nums.empty()) {
            results.push_back(vector<int>());
            return results;
        }
        
        sort(nums.begin(), nums.end());    
        helper(nums, 0, sol, results);
        return results;
    }
    
    void helper(vector<int>&nums, int index, vector<int>&sol, vector<vector<int>>&results) {
        results.push_back(sol);
        for (int i=index; i<nums.size(); ++i) {
            if ((i!=index) && (nums[i-1]==nums[i]))  //去重
                continue;
            sol.push_back(nums[i]);
            helper(nums, i+1, sol, results);
            sol.pop_back();
        }
    }

为啥这个可以去重呢? 以[1,2,2]为例，

这里写图片描述

      if ((i!=index) && (nums[i-1]==nums[i]))  //去重
                continue;

参考上面的代码，
第2行，取到[2]之后，就不会取第2个2了。
第3行，取到[1,2]之后，不会再取下一个[1,2]。同时它继续调用helper(,index+1,) 这里index+1=2，所以进helper()之后，index=2, i=2==index(第一次)，所以第4行还是会有[1,2,2]。

同样，回溯到[2]之后会继续调用helper(,index+1,)。这里index+1=2。所以第3行还是会有[2,2]，因为i==index。

网上的解答：
凡是i= index的时候，即便和前一个数相等，也是sol的第一次取到，也是最深的搜索结果一定要获得。如[1,2,2]中sol=[1,2]开始搜索, index将指向第二个2开始搜索(index= 2)，但由于开始i==index, 仍然需要取以获得[1,2,2]，只因为和前一个数相等就continue会漏掉[1,2,2]。如果i > index, 那么这样的sol必然已经在之前取得过了并且被搜索过，就是重复的结果了，同样对[1,2,2]计算，如sol=[1]的情况下去搜索, index= 1,即从第一个2组成的[1,2]进行搜索，当完成并回溯后，下一个循环中，此时nums[2] = nums[1]且i = 2>index= 1, 同样的[1,2]已经在之前的回溯中都获得了全部的搜索结果，所以要continue.

i != index 实际上上保证递归到下一层的时候如果有重复数，还能被选入。比如[1,2,2],如果得到[1,2],dfs下一层应该是[1,2,2]，如果把i != index单纯换成i >0 的话，这里的第二个2就会被nums[i] == nums[i -1] 跳过而不加入subset，最后结果只有[1,2],没有[1,2,2]。

举例：
[1,2,2,2,2]
第一次 i=0,index=0; i=index; 1 入sol;
第二次 i=1,index=1;i=index;2 入sol；
第三次 i=2, index=2;nums[3]==nums[2]&&i=index, 跳过（continue，所以index 并不增加）;
第四次 i=3,index=2; nums[4]==nums[3]&&i>index, 跳过（continue）；

解法2：Subset II也可以用BFS。我参考了Subset的解法，不过这里我用了sort和multimap。
代码如下：

class Solution {
public:
    /**
     * @param nums: A set of numbers.
     * @return: A list of lists. All valid subsets.
     */
    vector<vector<int>> subsetsWithDup(vector<int> &nums) {
        vector<vector<int>> vv;
        int n = nums.size();
        
        sort(nums.begin(), nums.end());
        unordered_map<int, int> um; //number, count
        for (auto i : nums) {
            if (um.find(i) == um.end()) {
                um[i] = 1;
            } else {
                um[i]++;
            }
           
        }
        
        queue<vector<int>> q;
        q.push({});  //push {}
        
        while(!q.empty()) {
            vector<int> v = q.front();
            q.pop();
            vv.push_back(v);
            
            unordered_map<int, int> um_v;
            for (auto i : v) {
                if (um_v.find(i) == um_v.end()) {
                    um_v[i] = 1;
                } else {
                    um_v[i]++;
                }
            }

            for (int i = 0; i < n; ++i) {
                if (v.size() == 0 ||
                    v.back() < nums[i] ||
                    ((v.back() == nums[i]) && (um_v[nums[i]] < um[nums[i]]))) {
                    vector<int> v2 = v;
                    v2.push_back(nums[i]);
                    if (q.back() != v2) {
                        q.push(v2);
                    }
                }
            }
        }
        
        return vv;
    }
};

代码同步在
https://github.com/luqian2017/Algorithm

纸上得来终觉浅绝知此事要躬行

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
LintCode-17: Subset 和 Subset II (搜索题中的超级经典！）

这题有4种解法，其中DFS两种，BFS一种，位运算一种。解法1： DFS 通用解法。注意: 1) 是每次进入helper()的sol都是一个解，所以不用等到index=nums.size()再存到results里面。 2) vector &amp;amp;amp;lt; vector &amp;amp;amp;lt; int&amp;amp;amp;gt; &amp;amp;amp;gt; results; results的值会是[]。如果想让它变成[[]]，
复制链接

扫一扫