Subsets II（集合的子集）

题目

Given a collection of integers that might contain duplicates, S, return all possible subsets.

Note:

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

For example,
If S = [1,2,2], a solution is:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

思路

最简单的方法是，将 集合的子集 代码得到的结果，去除重复的元素即可，当然复杂度有些高。

或者在生成子集合时，判断该集合是否满足条件，再决定是否压入结果中。

class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<int>> result;  
        vector<int> tmpv;  
        sort(S.begin(),S.end());
        myfun(result, tmpv, S, 0, S.size()-1);
        
        return result;  
    }  
      
    void myfun(vector<vector<int>> &result, vector<int> &vec, vector<int> &S, int i, int n)  
    {  
        if(i>n)
        {
            if(result.size()<=0 || !isSame(result.back(),vec))
                result.push_back(vec);
        }
        else
        {
            vec.push_back(S[i]);  
            myfun(result, vec, S, i+1, n);  
            vec.pop_back();    
            myfun(result, vec, S, i+1, n);  
        }
    } 
    
    bool isSame(vector<int> &src, vector<int> &dst)
    {
        if(src.size()!=dst.size())
            return false;
        for(int i=0;i<src.size();i++)
            if(src[i]!=dst[i])
                return false;
        return true;
    }
    
};

上述去除重复的判断，并不能适应所有的情况，例如：[ 1, 2, 2, 3]  可以得到正确结果，但是 [1, 1, 2, 2, 3] 就不行。

因为只是与前一个集合相比较而已，不会去除所有的重复集合。

贴出来只是作为参考而已。

想到数据结构 Set 可以去除重复元素，所以用set 一试：

class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        set<vector<int>> result;    
        vector<int> tmpv;    
        sort(S.begin(),S.end());  
        myfun(result, tmpv, S, 0, S.size()-1);  
          
        return vector<vector<int>>(result.begin(),result.end());    
    }    
        
    void myfun(set<vector<int>> &result, vector<int> &vec, vector<int> &S, int i, int n)    
    {    
        if(i>n)  {
            result.insert(vec);  
        }  
        else  
        {  
            vec.push_back(S[i]);    
            myfun(result, vec, S, i+1, n);    
            vec.pop_back();      
            myfun(result, vec, S, i+1, n);    
        }  
    }        
};  

可以轻松过大数据。

代码三

更简洁，高效

class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<int>> result;    
        vector<int> tmpv;    
        sort(S.begin(),S.end());  
        myfun(result, tmpv, S, 0);            
        return result;    
    }    
        
    void myfun(vector<vector<int>> &result, vector<int> &vec, vector<int> &S, int cur)    
    {  
        result.push_back(vec);  
        for(int i=cur; i<S.size(); i++) {
            if(i!=cur && S[i]==S[i-1])  
                continue;
            vec.push_back(S[i]);    
            myfun(result, vec, S, i+1);    
            vec.pop_back();  
        }
    }        
};  

最新 java

public class Solution {
    
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        Arrays.sort(nums);
        subSet(result, list, 0, nums);
        return result;
    }

    // public List<List<Integer>> subsetsWithDup(int[] nums) {
    //     List<List<Integer>> result = new ArrayList<List<Integer>>();  
    //     List<Integer> list = new ArrayList<Integer>();  
    //     Arrays.sort(nums);  
    //     subSet(result, list, 0, nums);  
    //     return result;  
    // }  
      
    private void subSet(List<List<Integer>> result, List<Integer> list, int cur, int[] nums){  
        result.add(new ArrayList<Integer>(list));  
        for(int i=cur; i<nums.length; i++){
            // if(i != cur && nums[i] == nums[i-1]){
            //     continue;
            // }
            list.add(nums[i]);  
            subSet(result, list, i+1, nums);  
            list.remove(list.size()-1);  
        }
    }  
    
    // private void subSet(List<List<Integer>> result, List<Integer> list, int cur, int[] nums){
    //     if(cur == nums.length){
    //         result.add(new ArrayList<Integer>(list));
    //     } else {
    //         list.add(nums[cur]);
    //         subSet(result, list, cur+1, nums);
    //         list.remove(list.size()-1);
    //         subSet(result, list, cur+1, nums);
    //     }
    // }
}