leetcode subsetsII

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) 
    {
        int size = S.size();
        set<vector<int> > sset;
        sort(S.begin(), S.end());
        queue<vector<int> > que;
        queue<vector<int> > posque;
        for (int i=0;i<size;i++)
        {
            vector<int> tmp1;
            vector<int> tmp2;
            tmp1.push_back(S[i]);
            tmp2.push_back(i);
            que.push(tmp1);
            posque.push(tmp2);
        }
        while(!que.empty())
        {
            vector<int> tmp1 = que.front();
            vector<int> tmp2 = posque.front();
            sort(tmp1.begin(), tmp1.end());
            que.pop();
            posque.pop();
            if (sset.find(tmp1) == sset.end())
            {
                sset.insert(tmp1);
                for (int i=0;i<size;i++)
                {
                    vector<int> tmp3 = tmp1;
                    vector<int> tmp4 = tmp2;
                    if (find(tmp2.begin(), tmp2.end(), i) == tmp2.end())
                    {
                        tmp3.push_back(S[i]);
                        tmp4.push_back(i);
                        que.push(tmp3);
                        posque.push(tmp4);
                    }
                }
            }
        }
        vector<vector<int> > res (sset.begin(), sset.end());
        res.insert(res.begin(), vector<int> ());
        return res;
    }
};



//dfs  时间过久
class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) 
    {
        int size = S.size();
        set<vector<int> > sset;
        vector<int>tmp;
        set<int>flag;
        
        sort(S.begin(), S.end());
        DFS(sset, tmp, 0, S, flag);
        return vector<vector<int> >  (sset.begin(), sset.end());
    }
    void DFS(set<vector<int> >&sset, vector<int>tmp, int sequence, vector<int> &S, set<int>&flag)
    {
        if (sequence == S.size())
        {
            sort(tmp.begin(), tmp.end());
            sset.insert(tmp);
            return;
        }
        DFS(sset, tmp, sequence+1, S, flag);
        for (int i=0;i<S.size();i++)
        {
            if (flag.find(i) == flag.end())
            {
                tmp.push_back(S[i]);
                flag.insert(i);
                DFS(sset, tmp, sequence+1, S, flag);
                tmp.pop_back();
                flag.erase(i);
            }
        }
    }
};

测试

#include"head.h"

class Solution1 {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) 
    {
        int size = S.size();
        set<vector<int> > sset;
        for (int i=0;i<size;i++)
        {
            for (int j=i;j<=size;j++)
            {
                vector<int> tmp(S.begin()+i, S.begin()+j);
                sset.insert(tmp);
            }
        }
        return vector<vector<int> > (sset.begin(), sset.end());
    }
};

class Solution2 {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) 
    {
        int size = S.size();
        set<vector<int> > sset;
        sort(S.begin(), S.end());
        queue<vector<int> > que;
        queue<vector<int> > posque;
        for (int i=0;i<size;i++)
        {
            vector<int> tmp1;
            vector<int> tmp2;
            tmp1.push_back(S[i]);
            tmp2.push_back(i);
            que.push(tmp1);
            posque.push(tmp2);
        }
        while(!que.empty())
        {
            vector<int> tmp1 = que.front();
            vector<int> tmp2 = posque.front();
            sort(tmp1.begin(), tmp1.end());
            que.pop();
            posque.pop();
            if (sset.find(tmp1) == sset.end())
            {
                sset.insert(tmp1);
                for (int i=0;i<size;i++)
                {
                    vector<int> tmp3 = tmp1;
                    vector<int> tmp4 = tmp2;
                    if (find(tmp2.begin(), tmp2.end(), i) == tmp2.end())
                    {
                        tmp3.push_back(S[i]);
                        tmp4.push_back(i);
                        que.push(tmp3);
                        posque.push(tmp4);
                    }
                }
            }
        }
        vector<vector<int> > res (sset.begin(), sset.end());
        res.insert(res.begin(), vector<int> ());
        return res;
    }
};


class Solution {
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) 
    {
        int size = S.size();
        set<vector<int> > sset;
        vector<int>tmp;
        set<int>flag;
        
        sort(S.begin(), S.end());
        DFS(sset, tmp, 0, S, flag);
        return vector<vector<int> >  (sset.begin(), sset.end());
    }
    void DFS(set<vector<int> >&sset, vector<int>tmp, int sequence, vector<int> &S, set<int>&flag)
    {
        if (sequence == S.size())
        {
            sort(tmp.begin(), tmp.end());
            sset.insert(tmp);
            return;
        }
        DFS(sset, tmp, sequence+1, S, flag);
        for (int i=0;i<S.size();i++)
        {
            if (flag.find(i) == flag.end())
            {
                tmp.push_back(S[i]);
                flag.insert(i);
                DFS(sset, tmp, sequence+1, S, flag);
                tmp.pop_back();
                flag.erase(i);
            }
        }
    }
};

int main()
{
    Solution s;
    int A[] = {1,2,2};
    vector<int> S(A,A+3);
    vector<vector<int> > res = s.subsetsWithDup(S);
    printvectorint2(res);
}