子集与子集和问题（Subset sum）的递归回溯解

所谓子集，是一个数学中的概念。例如一个集合S = {1,2,3,4,5}，那么X = {1,3,5}就是它的一个子集，1+3+5等于9就是对应于X的一个子集和。其实子集对于一个数组来说，就是相当于一个子序列（不是子数组，因为子序列意味着可以不连续，而子数组往往是连续的）；那么子集和也就是子序列和。

另外，子集问题需要与数学中的“排列”问题区分开来。因为子集往往是无序的，但排列是需要考虑顺序的；所以子集问题常常只是一个“组合”问题，而不是“排列”问题。

从另一个角度讲，这种子集和问题是一种背包问题的特例。

【问题1】

下面举一个退化（之所以说退化，因为这里的子集的大小是2，比较特殊）的子集和问题的例子，出自《编程之美》P.178的问题：快速寻找满足条件的两个数。

问题如下：给定一个数M，在数组arr中寻找两个数，使得这两个数之和等于M。

最初的想法就是：把数组中任意两个数的和求出来（复杂度是N^2），然后在这个和的数组中遍历，查找是否存在等于M的数。

但是这个问题还有更巧妙的方法，采用“变治”：将问题转化为另一个问题再求解。第一种变治方法就是将求两个数的和，转化为是否能在数组中找到M减去数组任意元素的差。但是这种方案没有降低任何复杂度。于是想到了第二种“变治”方法：对数组进行预处理排序，然后从数组的两头用两个指针开始向中间搜索（如果两个指针所指的和小于M，则左指针右移；反之则右指针左移）。

【问题2】

还是《编程之美》中的“数组分割”问题，详见P207。

【问题3】

输出一个集合的所有子集，也就是一个集合的所有组合（你想到了什么？）。

也有递归的解法，这里的递归思想就是：

n个数，每个数取或不取，
f(判断第i个数)
{
若n个数都判断完(i>=n)，输出刚才所取的数，返回。
否则：
不取第i个数，
f(判断第i+1个数)
取第i个数，
f(判断第i+1个数)
}
代码如下：

#include <iostream>
#include <vector>

using namespace std;

void all_subset( int arr[], unsigned int size, vector<bool>& contains, int depth )
{
//when reach the needed length, output
if ( depth == size )
{
for( int j = 0 ; j < size ; j++ )
{
if( contains[j] )
cout<<arr[j]<<" ";
}
cout<<endl;
}
else
{
// generate the result that doesn't contain arr[depth]
contains[depth] = false;
all_subset( arr, size, contains, depth+1 );
// generate the result that contains arr[depth]
contains[depth] = true;
all_subset( arr, size, contains, depth+1 );
}
return;
}

int main()
{
int s[] = { 1, 2, 3, 4, 5 };
int size = sizeof(s)/sizeof(int);
vector<bool> contains( 5, false );
all_subset( s, 5, contains, 0 );
}
用形象的“状态空间树”来表示上面的过程，如下：



我们假设对于一个集合生成所有子集的函数为F。那么F(1,2,3,4,5)将由两种可能组成：（1）对除1之外的元素组成的集合施加F；（2）对必然包含1在内的所有元素组成的集合施加F。注意：这两种情况是互斥的，所以不可能有情况重复！然后继续递归下去，就能生成最后结果。

===============================

当然这个问题也有另外一种解法：我们知道一个集合的子集的个数就等于其所有组合之和，即任选1个元素的集合个数+任选2个元素的集合个数+任选3个元素的集合个数+......+任选N个元素的集合个数，最后结果呢是2的N次方个。既然是2的N次方，我们就可以用二进制位表示，如果某位为1，则表示这个集合中含有这一位所代表的元素。例如一个集合是{1,2,3,4,5}，则二进制10011就表示这个集合为{1,4,5}。这个代码我就不写了，然后将这个数每次加1，只要判断某位是否为1即可。

【问题4】

子集和问题。题目如下：

给定n 个整数的集合X={x1，x2，......，xn}和一个正整数y，编写一个回溯算法，
在X中寻找子集Yi，使得Yi中元素之和等于y。
下面是回溯法的代码：

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

//find if the given subset sum exists.
int findSubsetSum( vector<int>& arr, int given, vector<bool>& included )
{
int cur = 0; // 指向当前值.
int sum = 0; // 当前子集合和.

while( cur >= 0 )
{
//if current one is not included
if( false == included[cur])
{
//include current one
included[cur] = true;
sum += arr[cur];
//find the given subset sum
if( sum == given )
{
return 1;
}
else if( sum > given ) //exceed the given sum
{
included[cur] = false;
sum -= arr[cur];
}
cur++;
}
//backtrace
if( cur >= arr.size() )
{
/*
** 下面两个循环依次排除匹配不成功的结果中
** 包括在结果内以及不包括在结果内的元素
** 直到找到下一个包括在结果内的元素
** 例如：用1和0表示包括和未包括
** 若结果为1110011，则第三个1为所找元素
** 将其变为0，但是从第4个0开始遍历。
**/
while( true == included[cur-1] )
{
cur--;
included[cur] = false;
sum -= arr[cur];
//backtrace to the head
if(cur < 1)
return 0;
}
while( false == included[cur-1] )
{
cur--;
if( cur < 1 )
return 0;
}
//change the status of current - 1,not current!
included[cur-1] = false;
sum -= arr[cur-1];
}
}
return 0;
}

int main()
{
int arr[] = { 2,5,15,8,20 };
vector<int> v( arr, arr + sizeof(arr)/sizeof(int) );
vector<bool> included( sizeof(arr)/sizeof(int), false );
int given = 33;//5+8+20

if( findSubsetSum( v, given, included ) )
{
vector<bool>::iterator iterb = included.begin();
vector<int>::iterator iteri = v.begin();
for( ; iterb != included.end() ; iterb++,iteri++ )
{
if( *iterb )
cout<<*iteri<<endl;
}
}
}
这个问题还有动态规划的方法，以后补充上。

通过 Wiz 发布