背包问题——“01背包”最优方案总数分析及实现

-----Edit by ZhuSenlin HDU

本人博文<<背包问题——“01背包”详解及实现（包含背包中具体物品的求解）>>中已谈过01背包，这里再重写一下01背包的动态规划状态及状态方程：

 设背包容量为V，一共N件物品，每件物品体积为C[i]，每件物品的价值为W[i]

1） 子问题定义：F[i][j]表示前i件物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值。

2） 根据第i件物品放或不放进行决策

                        (1-1)

 

         最优方案总数这里指物品总价值最大的方案数。

         我们设G[i][j]代表F[i][j]的方案总数，那么最总结果应该是G[N][V]。我们初始化G[][]为1，因为对每个F[i][j]至少应该有一种方案，即前i件物品中选取若干件物品放入剩余空间为j的背包使其价值最大的方案数至少为1，因为F[i][j]一定存在。

         下面开始分析怎么求G[i][j]。对于01背包来说：

        如果F[i][j]=F[i-1][j]且F[i][j]!=F[i-1][j-C[i]]+W[i]说明在状态[i][j]时只有前i-1件物品的放入才会使价值最大，所以第i件物品不放入，那么到状态[i][j]的方案数应该等于[i-1][j]状态的方案数即G[i][j]=G[i-1][j]；

        如果F[i][j]=F[i-1][j-C[i]]+W[i] 且F[i][j]!=F[i-1][j]说明在状态[i][j]时只有第i件物品的加入才会使总价值最大，那么方案数应该等于[i-1][j-C[i]]的方案数，即G[i][j]=G[i-1][j-C[i]]；

        如果F[i][j]=F[i-1][j-C[i]]+W[i] 且F[i][j]=F[i-1][j]则说明即可以通过状态[i-1][j]在不加入第i件物品情况下到达状态[i][j]，又可以通过状态[i-1][j-C[i]]在加入第i件物品的情况下到达状态[i][j]，并且这两种情况都使得价值最大且这两种情况是互斥的，所以方案总数为G[i][j]=G[i-1][j-C[i]]+ G[i-1][j]。

        

经过上面的分析，得出下述伪代码：

  F[0][] ← 0

  F[][0] ← 0

  G[][ ] ← 1

  for i ← 1 to N

      do for j ← 1 to V

          F[i][j] ← F[i-1][j]

          G[i][j] ← G[i-1][j]

          if (j >= C[i])

              if (F[i][j] < F[i-1][j-C[i]]+W[i])

                  then F[i][j] ← F[i-1][j-C[i]]+W[i]

                      G[i][j] ← G[i-1][j-C[i]]

              else if (F[i][j] = F[i-1][j-C[i]]+W[i])

                  then G[i][j] ← G[i-1][j]+G[i-1][j-C[i]]

  return F[N][V] and G[N][V]

 上述方法在保存状态F[][]及G[][]时需要O(NV)的空间复杂度，下面我们对空间复制度进行优化。

 

压缩空间复杂度为O(V)

F[i][j]与G[i][j]只分别与F[i-1][]和G[i-1][]的状态有关，所以我们可以用两个一维数组F[]和G[]来替换二维数组F[][]和G[][]。具体思想请看博文

<<背包问题——“01背包”详解及实现（包含背包中具体物品的求解）>>

 

下面直接给出伪代码：

  F[] ← 0

  G[] ← 1

  for i ← 1 to N

      do for j ← V to C[i]

          if (F[j] < F[j-C[i]]+W[i])

              then F[j] ← F[j-C[i]]+W[i]

                   G[j] ← G[j-C[i]]

          else if (F[j] = F[j-C[i]]+W[i])

              then G[j] ← G[j]+G[j-C[i]]

  return F[V] and G[V]

 

下面对数据表给出以上两种不同空间复杂度的详细代码：

背包数据表（背包容量10）

物品号i	1	2	3	4	5
体积C	3	2	5	4	5
价值W	5	5	10	10	10

#include <iostream>
#include <cstring>
#include "CreateArray.h"		//该头文件是动态创建和销毁二维数组，读者自己实现

using namespace std;

时间复杂度O(VN),空间复杂度为O(VN)：

int Package01Optimal(int Weight[], int Value[], int nLen, int nCapacity)
{
	int** MaxValueTable = NULL;
	int** OptimalTable = NULL;
	CreateTwoDimArray(MaxValueTable,nLen+1,nCapacity+1);	//创建最大价值表
	CreateTwoDimArray(OptimalTable,nLen+1,nCapacity+1);	//创建最优方案总数表

	//initiallize all OptimalTable[][] with 1
	for(int i = 0; i <= nLen; i++)
		for(int j = 0; j <= nCapacity; j++)
			OptimalTable[i][j] = 1;
	
	for(int i = 1; i <= nLen; i++)
	{
		for(int j = 1; j <= nCapacity; j++)
		{
			MaxValueTable[i][j] = MaxValueTable[i-1][j];
			OptimalTable[i][j] = OptimalTable[i-1][j];
			if(j >= Weight[i-1])
			{
			   	if(MaxValueTable[i][j] < MaxValueTable[i-1][j-Weight[i-1]]+Value[i-1])
				{
					MaxValueTable[i][j] = MaxValueTable[i-1][j-Weight[i-1]]+Value[i-1];
					OptimalTable[i][j] = OptimalTable[i-1][j-Weight[i-1]];
				}
				else if(MaxValueTable[i][j] == (MaxValueTable[i-1][j-Weight[i-1]]+Value[i-1]))
				{
					OptimalTable[i][j] = OptimalTable[i-1][j]+OptimalTable[i-1][j-Weight[i-1]];
				}
			}
		}
	}

	cout << endl << "OptimalCount:" << OptimalTable[nLen][nCapacity] << endl;

	int nRet = MaxValueTable[nLen][nCapacity];
	DestroyTwoDimArray(MaxValueTable,nLen+1);	//销毁最大价值表，防止内存泄露
	DestroyTwoDimArray(OptimalTable,nLen+1);	//销毁最优方案总数表，防止内存泄露
	return nRet;
}

时间复杂度O(VN),空间复杂度为O(V)：

int Package01Optimal_Compress(int Weight[], int Value[], int nLen, int nCapacity)
{
	int * MaxValueTable = new int [nCapacity+1];
	memset(MaxValueTable,0,(nCapacity+1)*sizeof(int));

	//initiallize all OptimalTable[] with 1
	int* OptimalTable = new int[nCapacity+1];
	for(int i = 0; i <= nCapacity; i++)
		OptimalTable[i] = 1;
	
	for(int i = 0; i < nLen; i++)
	{
		for(int j = nCapacity; j >=Weight[i]; j--)
		{
			if(MaxValueTable[j] < MaxValueTable[j-Weight[i]]+Value[i])
			{
				MaxValueTable[j] = MaxValueTable[j-Weight[i]]+Value[i];
				OptimalTable[j] = OptimalTable[j-Weight[i]];
			}
			else if(MaxValueTable[j] == MaxValueTable[j-Weight[i]]+Value[i])
				OptimalTable[j] = OptimalTable[j-Weight[i]]+OptimalTable[j];
		}
	}

	cout << endl << "OptimalCount:" << OptimalTable[nCapacity] << endl;

	int nRet = MaxValueTable[nCapacity];
	delete [] OptimalTable;
	delete [] MaxValueTable;
	return nRet;
}

测试代码：

int main()
{
	//int Weight[] = {1,1,1,1,1,1};
	//int Value[] =  {2,2,2,2,2,2};
	int Weight[] = {3,2,5,4,5};
	int Value[] =  {5,5,10,10,10};
	int nCapacity = 10;
	cout << "MaxValue:" << Package01Optimal(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;
	cout << "MaxValue:" << Package01Optimal_Compress(Weight,Value,sizeof(Weight)/sizeof(int),nCapacity) << endl;
	return 0;
}

本文部分内容参考《背包九讲》