0-1背包问题求解方法综述

算法分析与设计大作业

实验题目：0-1背包问题求解方法综述组员：

班级：

指导老师：

0-1背包问题求解方法综述

【摘要】：0-1背包问题是一个经典的NP-hard组合优化问题，现实

生活中的很多问题都可以以它为模型。本文首先对背包问题做了阐

述，然后用蛮力解法、动态规划算法、贪心算法和回溯解法对背包问

题进行求解，分析了0-1背包问题的数学模型,刻划了最优解的结构特

征,建立了求最优值的递归关系式。最后对四种算法从不同角度进行

了对比和总结。

【关键词】：0-1背包问题；蛮力解法；动态规划算法；贪心算法；回溯解法。

0.引言

0-1背包问题是指给定n个物品,每个物品均有自己的价值vi和重量

wi(i=1,2,…,n),再给定一个背包,其容量为W。要求从n个物品中选出一部分物

品装入背包,这部分物品的重量之和不超过背包的容量,且价值之和最大。单个物

品要么装入,要么不装入。很多问题都可以抽象成该问题模型,如配载问题、物资

调运[1]问题等,因此研究该问题具有较高的实际应用价值。目前,解决0-1背包问

题的方法有很多,主要有动态规划法、回溯法、分支限界法、遗传算法、粒子群

算法、人工鱼群算法、蚁群算法、模拟退火算法、蜂群算法、禁忌搜索算法等。

其中动态规划、回溯法、分支限界法时间复杂性比较高,计算智能算法可能出现

局部收敛,不一定能找出问题的最优解。文中在动态规划法的基础上进行了改进,

提出一种求解0-1背包问题的算法,该算法每一次执行总能得到问题的最优解,是确定性算法,算法的时间复杂性最坏可能为O(2n)。 1.0-1背包问题描述

0-1背包问题(KP01)是一个著名的组合优化问题。它应用在许多实际领域,如项目选择、资源分布、投资决策等。背包问题得名于如何选择最合适的物品放置于给定背包中。本文主要研究背包问题中最基础的0/1背包问题的一些解决方法。

为解决背包问题，大量学者在过去的几十年中提出了很多解决方法。解决背包问题的算法有最优算法和启发式算法[2]，最优算法包括穷举法、动态规划法、分支定界法、图论法等，启发式算法包括贪心算法、遗传算法、蚁群算法、粒子算法等一些智能算法。

0-1背包问题一般描述为：给定n 种物品和一个背包。物品i 的重量是w(i)，其价值为v(i)，背包的容量为c 。问应该如何选择装入背包的物品，使得装入背包中的物品的总价值最大？

在选择装入背包的物品时，对每种物品i 只有两种选择，即装入背包或不装入背包。不能将物品i 装入背包多次，也不能只装入部分的物品i 。因此，该问题称为0-1背包问题。

此问题的形式化描述是，给定n i v w c i i ≤≤>>>1000，，，，要求找出一个n 元0-1向量n i x x x x i n ≤≤∈1}1,0{21，），，，，（ ，使得c

x w i i i ≤∑=n

1

，而且i

n

i i x v ∑=1

达到最大。

数学模型：∑=n

i i i x v 1max

约束条件：

c

x

w

i

i

i

≤

∑

=

n

1

，n

i

x

i

≤

≤

∈1},1,0{

2.0-1背包问题的求解算法

2.1蛮力算法（brute force method）

2.1.1基本思想：

对于有n种可选物品的0/1背包问题，其解空间由长度为n的0-1向量组成,可用子集数表示。在搜索解空间树时，深度优先遍历，搜索每一个结点，无论是否可能产生最优解，都遍历至叶子结点，记录每次得到的装入总价值，然后记录遍历过的最大价值。

2.1.2代码实现:

#include

#include

using namespace std;

#define N 100 //最多可能物体数

struct goods //物品结构体

{

int sign; //物品序号

int w; //物品重量

int p; //物品价值

}a[N];

bool m(goods a,goods b)

{

return (a.p/a.w)>(b.p/b.w);

}

int max(int a,int b)

{

return a

}

int n,C,bestP=0,cp=0,cw=0;

int X[N],cx[N];

/*蛮力法求解0/1背包问题*/

int Force(int i)

{

if(i>n-1){

if(bestP

for (int k=0;k

bestP=cp;

}

return bestP;

}

cw=cw+a[i].w;

cp=cp+a[i].p;

cx[i]=1; //装入背包

Force(i+1);

cw=cw-a[i].w;

cp=cp-a[i].p;

cx[i]=0; //不装入背包

Force(i+1);

return bestP;

}

int KnapSack1(int n,goodsa[],int C,int x[])

{

Force(0);

return bestP;

}

int main()

{

goods b[N];

printf("物品种数n: ");

scanf("%d",&n); //输入物品种数

printf("背包容量C: ");

scanf("%d",&C); //输入背包容量

for (int i=0;i

{

printf("物品%d的重量w[%d]及其价值v[%d]: ",i+1,i+1,i+1);

scanf("%d%d",&a[i].w,&a[i].p);

b[i]=a[i];

}

int sum1=KnapSack1(n,a,C,X);//调用蛮力法求0/1背包问题

printf("蛮力法求解0/1背包问题:\nX=[ ");

for(i=0;i

cout<

printf("] 装入总价值%d\n",sum1);

bestP=0,cp=0,cw=0;//恢复初始化

}

2.1.3复杂度分析：

蛮力法求解0/1背包问题的时间复杂度为：2^n

2.2贪心算法（Greedy algorithm）

贪心算法通过一系列的选择来得到问题的解。贪心选择即它总是做出当前最好的选择[4]。贪心选择性质指所求问题的整体最优解可以通过一系列局部最优选择，这是贪心算法与动态规划算法的主要区别。

贪心算法每次只考虑一步，每一步数据的选取都必须满足局部最优条件。在枚举剩下数据与当前已经选取的数据组合获得的解中，提取其中能获得最优解的唯一的一个数据，加入结果数据中，直到剩下的数据不能再加入为止[6]。贪心算法不能保证得到的最后解是最佳的，也不能用来求最大或最小解问题，只能求满足某些约束条件的可行解围。

2.2.1算法设计

用贪心算法解决0-1背包问题一般有以下三种策略：

①价值最大者优先：在剩余物品中，选出可以装入背包的价值最大的物品，若背包有足够的容量，以此策略，然后是下一个价值最大的物品。但这种策略背包的承重量不能够得到有效利用，即得不到最优解。例如：n=3,w=[50,20,20],v=[10,7,7]c=55,得到的解是x=[1,0,0],这种方案的总价值为10，而最优解为[0,1,1],总价值为14。

②重量最小者优先：在剩余物品中，选择可以装入背包的重量最小的物品。但这种策略，不能保证重量小的是最有价值的，也不能得到最优解。例如：n=2,w=[10,20],v=[5,100],c=25，得到的解为x=[1,0],而最优解是[0,1]。

③单位价值最大者优先：根据价值与重量的比值i v /i w ，即单位价值，在剩下的物品中依次选取比值最大的物品装入背包。这种策略也不能得到最优解。例如：n=3,w=[20,15,15],v=[40,25,25],i v /i w =[2,5/3,5/3],c=30,得到的解x=[1,0,0],而最优解是[0,1,1]。但它是直觉上的一个近似解。本文讨论该策略。

策略3的具体步骤为：

第一步：计算每个物品的价值比i r =i v /i w ，i=1,2,…,n 。 第二步：对物品的价值比非递增排序。

第三步：重复下面操作，直到有序列表中留下物品。如果列表中的当前物品能够装入背包，就将它放入背包中，否则，处理下一个物品。 2.2.2 编程实现 #include"stdafx.h" #include #include #include

using namespacestd;

#define max 100 //自定义物品最大数void package(int v[],int w[],int n,int c) //定义包函数

{

doublea[max];

inti,totalv=0,totalw=0,index[max];

for(i=0;i

{

a[i]=(double)v[i]/w[i]; //单位价值计算

index[i]=i;

}

for(i=1;i

{

for(int j=0;j

{

if(a[j]

{

double b=a[j];

a[j]=a[j+1];

a[j+1]=b;

int c=v[j];

v[j]=v[j+1];

v[j+1]=c;

int d=w[j];

w[j]=w[j+1];

w[j+1]=d;

int e=index[j];

index[j]=index[j+1];

index[j+1]=e;

}

}

}

cout<<"单位价值："; //输出单位价值

for(i=0;i

{

cout<

}

cout<

{

cout<

}

cout<

{

cout<

}

cout<

doublex[max]={0};

i=0;

while(w[i]<=c)

{

x[i]=1;

c=c-w[i];

i++;

}

cout<<"所选择的商品如下:"<

cout<<"序号i:\t重量w:\t价格v:\t"<

{

if(x[i]==1){

totalw=totalw+w[i];

totalv=totalv+v[i];

cout<

}

}

cout<<"背包的总重量为："<

}

int main(void) //主函数定义

{

LARGE_INTEGER begin,end,frequency;

QueryPerformanceFrequency(&frequency);

srand(time(0));

int n,i,x[max];

int v[max],w[max],W; //变量的定义

cout<<"请输入物品种数n和背包容量W:";

cin>>n>>W;

for(i=0;i

x[i]=0; //物品选择情况表初始化为0 for(i=0;i

{

v[i]=rand()%1000;

w[i]=rand()%1000;}

cout<<"商品的重量和价值如下："<

for(int i=0;i

{ cout<

cout<

}

QueryPerformanceCounter(&begin);

package(v,w,n,W); //函数的调用

QueryPerformanceCounter(&end);

cout<<"时间:"

<<(double)(end.QuadPart- begin.QuadPart) / frequency.QuadPart

<<"s"<

}

2.2.2运行结果

贪心算法求解0/1背包问题的时间复杂度为：(nlogn)

2.3 动态规划算法（Dynamic Programming）

20世纪50年代，美国数学家R.E.Bellman等人在研究多阶段决策过程的优化问题时，提出了著名的最优化原理，把多阶段过程转化为一系列单阶段问题，利用个阶段之间的关系，逐个求解，创立了解决这类过程优化问题的新方法——动态规划[3]。动态规划是基于递归的，通常不是一个解决KP有效的方式,因为空间消耗非常大,和最坏的和最好的计算工作通常是相同的[7]。动态规划算法与分治法类似，其基本思想也是将带求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是互相独立的。若用分治法解决这类问题，则分解得到的子问题数目太多，以至于最后解决原问题需要耗费指数时间。然而，不同子问题的数目常常只有多项式量级。在用分治法求解时，有些子问题被重复计算了许多次。如果我们能够保证已解决的子问题的答案，而在需要时找出已求出的答案，这样就可以避免大量的重复计算，从而达到多项式时间算法。为了达到此目的可以用一个表来记录所有已解决的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思想。具体的动态规划算法多种多样，但它们有相同的填表格式。

动态规划算法适用于解最优化问题。通常可按以下4个步骤设计：

（1）找出最优解的性质，并刻画其结构特征。

（2）递归地定义最优值。

（3）以自底向上的方式计算出最优值。

（4）根据计算最优值时得到的信息，构造最优解。

步骤（1）~（3）是动态规划算法的基本步奏。在需要求出最优值的情形，步骤（4）可以省去。若需要求出问题的最优解，则必须执行步骤（4）.此时，

在步骤（3）中计算最优解时，通常需记录更多的信息，以便在步骤（4）中，根据所记录的信息，快速构造出一个最优解。

使用动态规划求解问题，最重要的就是确定动态规划3要素：（1）问题的阶段；（2）每个阶段的状态；（3）从前一个阶段转化后一个阶段之间的递推关系[4]。

2.3.1分析最优解的性质，刻画最优解的结构特征——最优子结构性质分析 设），，，（n x x x 21所给0-1背包问题的一个最优解，则），，（n x x x 32是下面相应子问题的一个最优解： 目标函数：i

n

i i x v ∑=2

max

约束条件：

)2}(1,0{,112

n i x x w c x

w i n

i i

i ≤≤∈-≤∑=

证明：若），，（n x x x 32不是上述子问题的一个最优解，而），，，（n 32y y y 是他的最优解。由此可知，i i i n

i i x v y v ∑∑>=n

2

且c y w x w i n

i i ≤+∑=2

11。因此

c

y w x w x v y v x v i n

i i i

n

i i n i i ≤+>+∑∑∑===2

111

1211

这说明），，，（n y y x 21是原问题的一个更优解，从而），，，（n y y y 21不是所给原问题的最优解，产生矛盾。

所以），，（n x x x 32是上述子问题的一个最优解。 2.3.2递归关系

由于0-1背包问题的解是用向量），，，（n x x x 21来描述的。因此，该问题可以看做是决策一个n 元0-1向量），，，（n x x x 21。对于任意一个分量i x 的决策是

“决定i x =1或i x =0，i=1,2,…,n 。对1-i x 决策后，序列)(121-i x x x ，，， 已被确定，在决策i x 时，问题处于下列两个状态之一：

（1）背包容量不足以装下物品i ，则=0，装入背包的价值不增加； （2）背包容量足以装入物品i,则=1，装入背包的价值增加i v 。 在这种情况下，装入背包的价值最大化应该是对决策后的价值。 设所给0-1背包问题的子问题

n

k i x j x

w x v k k

n

i

k k

n

i

k k

k ≤≤∈≤∑∑==，，)1,0(max

的最优值为m(i,j),即m(i,j)是背包容量为j ，可选择的物品为i,i+1,…,n 时0-1背包问题的最优值。由0-1背包问题的最优子结构性质，可以建立计算m （i,j ）的递归式为：

n

n n

i i i i w j v w j w j v w j i m j i m w j j i m j n m j i m ≥<≤≥+-++<≤+==，，00)

}(),1(),,1(max{)

0)(,1({),({

),(

2.3.3算法设计

基于上面的讨论，求解0-1背包的动态规划算法步骤如下：

步骤1：当)1(n i w i ≤≤为正整数时，用数组w[n]来存放n 个物品的重量；数组v[n]来存放n 个物品的价值，背包容量为c ，数组M[n+1][c+1]来存放每一次迭代的执行结果；数组x[n]用来存储所装入背包的物品状态；

步骤2：初始化。数组M 的第0行第0列全部设置为0；

步骤3：循环阶段。按式（5）确定前i 个物品能够装入背包的情况下得到的最优值；

步骤3-1：i=1时，求出M[1][j],1≤j ≤c ； 步骤3-2：i=2时，求出M[2][j],1≤j ≤c ； ……

步骤3-n:i=n 时，求出M[n][c]。此时，M[n][c]便是最优值；

步骤4：确定装入背包的具体物品。从M[n][c]的值向前推，如果M[n][c]>M[n-1][c]，表明第n 个物品被装入背包，则n x =1，前n-1个物品没有被装入背包，则n x =0，前n-1个物品被装入容量为c 的背包中。以此类推，知道确定第1个物品是否被装入背包为止。由此，得到下面的关系式： 如果M[i][j]=M[i-1][j],说明第i 个物品没有被装入背包，则i x =0； 如果M[i][j]>M[i-1][j],说明第i 个物品被装入背包，则i x =1，j=j-i w 。 按照上述关系式，从M[n][c]的值向前倒推，即j 初始为c ，i 初始为n,即可确定装入背包的具体物品。

上述算法需要O （nc ）时间计算时间。不过上述算法有2个明显的确点。一是算法要求所给物品的重量i w （1≤i ≤n ）是整数；二是当背包容量c 很大时，算法需要的计算时间较多。 2.2.2运行结果

贪心算法求解0/1背包问题的时间复杂度为：O（nm）

2.4 回溯法（Backtracking）

2.4.1回溯法0-1背包问题的实现

回溯法是一种系统地搜索问题解答的方法。为了实现回溯，首先需要为问题定义一个解空间，这个解空间必须至少包含问题的一个解(可能是最优的)。一旦定义了解空间的组织方要选择一个对象的子集，将它们装人背包，以便获得的收益最大，则解空间应组织成子集树的形状。首先形成一个递归算法，去找到可获得的最大收益。然后，对该算法加以改进，形成代码。改进后的代码可找到获得最大收益时包含在背包中的对象的集合。

左子树表示一个可行的结点，无论何时都要移动到它，当右子树可能含有比当前最优解还优的解时，移动到它。一种决定是否要移动到右子树的简单方法是r为还未遍历的对象的收益之和，将r加到cp(当前节点所获收益)之上，若( r+cp)

<=bestp(目前最优解的收益)，则不需搜索右子树。一种更有效的方法是按收益密度vi/wi对剩余对象排序，将对象按密度递减的顺序去填充背包的剩余容量。

2.4.2 编程实现如下

#include"stdafx.h"

#include

#include

#include

#include

using namespace std;

#defineN 100 //最多可能物体数

structgoods //物品结构体

{

int sign; //物品序号

int w; //物品重量

int p; //物品价值

}a[N],b[N];

bool m(goods a,goods b)

{

return (a.p/a.w)>(b.p/b.w);

}

int max1(int a,intb) //最大函数定义

{

return a

}

int n,W,bestP=0,cp=0,cw=0;

int X[N],cx[N]; //变量定义

int BackTrack(int i)

{

if(i>n-1){

if(bestP

for (int k=0;k

bestP=cp;

}

returnbestP;

}

if(cw+a[i].w<=W){ //进入左子树

cw=cw+a[i].w;

cp=cp+a[i].p;

cx[a[i].sign]=1; //装入背包

BackTrack(i+1);

cw=cw-a[i].w;

cp=cp-a[i].p; //回溯，进入右子树}

cx[a[i].sign]=0; //不装入背包