Subsets II [leetcode] 从获取子集的递归和循环方法说起，解决重复子集的问题

这一题和Permutation II很像，一个是排列一个是组合。

我们理清思路，从最基本的获取子集的方法开始分析：

获取子集总的来说可以用循环或者递归做，同时还可以根据数字对应的binary code得到。

例如s = {x,y,z}可以生成的组合有：x,y,z,xy,yz,xz,xyz,0

第一种思路：

1. 维护一个集合Set(i)，包含s[0...i]可生成的所有组合

s[0...i+1]可以生成的所有组合为：Set(i) + (Set(i)+s[i+1])

void permutation(vector<int> &s, vector<vector<int>> & res, int index)
{
permutation(s, res,  index + 1);
for (int i = res.size(); i >= 0; i—)
{
res.push_back(res[i] + s[index]);
}
}

以上是一个递归的伪代码，我们可以将其改为循环的：

vector<vector<int>> permutation(vector<int> &s)
{
vector<vector<int>> res;
for (int index = 0; index < s.size(); index++)
{
for (int i = res.size(); i >= 0; i—)
{
res.push_back(res[i] + s[index]);
}
}
return res;
}

2.下面考虑如何去除相同的子集：

当输入为{x,y,y}时，对index = 0,res={0, x}; index = 1时res={0,x,y,xy}

当index=2时，问题来了。如果对0和x都加上y，会生成重复的子集y和xy。此时res={0,x,y,xy,y,xy,yy,xyy}

重复的原因是我们将index=1时处理过的集合{0,x}又处理了一遍。

所以我们加上preEnd标记上一个index处理过的集合的结尾位置（如{0,x}）。

如果s[index]和s[index-1]一样，preEnd为处理s[index-1]之前res的大小；否则preEnd=0

代码如下:

vector<vector<int> > subsetsWithDup(vector<int> &s) {
sort(s.begin(), s.end());
vector<vector<int>> res;
res.push_back(vector<int>());
int preEnd = 0;
for (int i = 0; i < s.size(); i++)
{
int resSize = res.size();
for (int j = preEnd; j < resSize; j++)
{
vector<int> curSet = res[j];
curSet.push_back(s[i]);
res.push_back(curSet);
}
if (i + 1 < s.size() && s[i] == s[i + 1]) preEnd = resSize;
else preEnd = 0;
}
return res;
}

第二种思路：

1.再回看所有的子集{x,y,z,xy,yz,xz,xyz,0}。我们发现x没有出现在第二位，y没有出现在第三位...

1.1设{x,y,z}为Set1，则对Set1中的每个元素，向其添加可行的其他元素，如x可以添加y和z；y可以添加z；z已经到末尾了，不能添加其他元素了。所以我们得到Set2{xy,xz,yz}。

1.2 接着向Set2添加元素，得到Set3{xyz}。Set3不可能再扩展出其他子集了，所以循环结束。

{0, Set1, Set2, Set3}是最终结果。

递归的伪代码如下：

void permutation(vector<int> &s, int inPos, int outPos, vector<int> & out, vector<vector<int>> & res)
{
for (int index = inPos; index < s.size(); index++)
{
out[outPos] = s[index];
res.push_back(out);
permutation(s, index + 1, outPos + 1, out, s);
}
}

循环的时候，依次生成Set1,Set2,Set3。代码如下：

vector<vector<int> > subsets(vector<int> &s) {
vector<vector<int>> res;
vector<int> inPos;
res.push_back(vector<int>());
inPos.push_back(-1);
sort(s.begin(), s.end());

for (int i = 0; i < res.size(); i++)
{
for (int index = inPos[i] + 1; index < s.size(); index++)
{
vector<int> temp = res[i];
temp.push_back(s[index]);
res.push_back(temp);
inPos.push_back(index);
}
}
return res;
}

下面考虑有重复元素的情况：

在生成每个Seti的时候，均有可能遇见重复元素，从而生成重复子集，所以在里层的for循环里要跳过相同元素。

这里只需要加上简单的一句话即可 while(index + 1 < s.size() && s[index] == s[index + 1]) index++;

代码如下：

vector<vector<int> > subsetsWithDup(vector<int> &s) {
vector<vector<int>> res;
vector<int> inPos;
res.push_back(vector<int>());
inPos.push_back(-1);
sort(s.begin(), s.end());

for (int i = 0; i < res.size(); i++)
{
for (int index = inPos[i] + 1; index < s.size(); index++)
{
vector<int> temp = res[i];
temp.push_back(s[index]);
res.push_back(temp);
inPos.push_back(index);
while(index + 1 < s.size() && s[index] == s[index + 1]) index++;
}
}
return res;
}

第三种思路：
当前子集包含/不包含 index

用递归来做的时候很简单，伪代码如下：

void permutation(vector<int> &s, int inPos, vector<int> & out, vector<vector<int>> & res)
{
if (inPos == s.size())
{
res.push_back(out);
return;
}
permutation(s, inPos + 1, out, res);
permutation(s, inPos + 1, out + s[inPos], res);
}

非递归实现和第一种思路类似

第四种思路：

含有K个元素的集合有2^K个子集，每个数字的第i位代表是否含有第s[i]个元素