LeetCode_Subsets II

最新推荐文章于 2020-12-16 23:46:01 发布

leileicaocao

最新推荐文章于 2020-12-16 23:46:01 发布

阅读量419

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/leileicaocao/article/details/9182627

版权

LeetCode 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

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:   
        void subsetsWithoutDup(vector<vector<int> > &ans, vector<int> &s)
        {
            vector<int> empty;
        	ans.push_back(empty);
        	int size = s.size();
        	if (size == 0)
        	{
        		return;
        	}
        	for (int i = 0; i < size; ++i)
        	{
        		int num = s[i];
        		int len = ans.size();
        		for (int j = 0; j < len; ++j)
        		{
        			vector<int> tmp = ans[j];
        			tmp.push_back(num);
        			ans.push_back(tmp);
        		}
        	}
        }
        
        vector<vector<int> > subsetsWithDup(vector<int> &s) 
        {
            vector<vector<int> > ans;
            if (s.size() == NULL)
            {
                return ans;
            }
            sort(s.begin(), s.end());
            int size = s.size();
            vector<int> dup;
            int last = s[0];
            int count = 1;
        	int i = 1;
            for (; i < size; ++i)
            {
                if (s[i] == last)
                {
                    ++count;
                    --size;
                    --i;
                    s.erase(s.begin() + i);                
                }
                else
                {
                    if (count > 1)
                    {
                        dup.push_back(last);
                        dup.push_back(count);
        				--i;
                        s.erase(s.begin() + i);
                        --size;
                    }
                    last = s[i];
                    count = 1;
                }
            }
        	if (count > 1)
        	{
        		dup.push_back(last);
                dup.push_back(count);
        		--i;
                s.erase(s.begin() + i);
                --size;
        	}
        	subsetsWithoutDup(ans, s);
        	int num = 0;
        	int total = dup.size();
        	while (num < total)
        	{
        		int size = ans.size();
        		int nNum = dup[num];
        		int nCount = dup[num + 1];
        		num += 2;
        		for (int i = 0; i < nCount; ++i)
        		{
        			int start = ans.size() - size;
        			int end = ans.size();
        			for (int j = start; j < end; ++j)
        			{
        				vector<int> tmp = ans[j];
        				tmp.push_back(nNum);
        				ans.push_back(tmp);
        			}
        		}
        	}
        	int ansNum = ans.size();
        	for (int i = 0; i < ansNum; ++i)
        	{
        		sort(ans[i].begin(), ans[i].end());
        	}
        	return ans;
        }
};