(完整word版)0-1背包问题求解方法综述
动态规划——01背包问题
动态规划——01背包问题⼀、最基础的动态规划之⼀01背包问题是动态规划中最基础的问题之⼀，它的解法完美地体现了动态规划的思想和性质。
01背包问题最常见的问题形式是：给定n件物品的体积和价值，将他们尽可能地放⼊⼀个体积固定的背包，最⼤的价值可以是多少。
我们可以⽤费⽤c和价值v来描述⼀件物品，再设允许的最⼤花费为w。
只要n稍⼤，我们就不可能通过搜索来遍查所有组合的可能。
运⽤动态规划的思想，我们把原来的问题拆分为⼦问题，⼦问题再进⼀步拆分直⾄不可再分（初始值），随后从初始值开始，尽可能地求取每⼀个⼦问题的最优解，最终就能求得原问题的解。
由于不同的问题可能有相同的⼦问题，⼦问题存在⼤量重叠，我们需要额外的空间来存储已经求得的⼦问题的最优解。
这样，可以⼤幅度地降低时间复杂度。
有了这样的思想，我们来看01背包问题可以怎样拆分成⼦问题：要求解的问题是：在n件物品中最⼤花费为w能得到的最⼤价值。
显然，对于0 <= i <= n,0 <= j <= w，在前i件物品中最⼤花费为j能得到的最⼤价值。
可以使⽤数组dp[n + 1][w + 1]来存储所有的⼦问题，dp[i][j]就代表从前i件物品中选出总花费不超过j时的最⼤价值。
可知dp[0][j]值⼀定为零。
那么，该怎么递推求取所有⼦问题的解呢。
显⽽易见，要考虑在前i件物品中拿取，⾸先要考虑前i - 1件物品中拿取的最优情况。
当我们从第i - 1件物品递推到第i件时，我们就要考虑这件物品是拿，还是不拿，怎样收益最⼤。
①：⾸先，如果j < c[i]，那第i件物品是⽆论如何拿不了的，dp[i][j] = dp[i - 1][j];②：如果可以拿，那就要考虑拿了之后收益是否更⼤。
拿这件物品需要花费c[i]，除去这c[i]的⼦问题应该是dp[i - 1][j - c[i]]，这时，就要⽐较dp[i - 1][j]和dp[i - 1][j - c[i]] + v[i]，得出最优⽅案。
背包问题求解方法综述
背包问题求解方法综述 IMB standardization office【IMB 5AB- IMBK 08- IMB 2C】算法分析与设计大作业实验题目：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)。
背包问题描述0-1背包问题(KP01)是一个着名的组合优化问题。
它应用在许多实际领域,如项目选择、资源分布、投资决策等。
背包问题得名于如何选择最合适的物品放置于给定背包中。
本文主要研究背包问题中最基础的0/1背包问题的一些解决方法。
动态规划之-0-1背包问题及改进
动态规划之-0-1背包问题及改进有N件物品和一个容量为V的背包。
第i件物品的重量是w[i]，价值是v[i]。
求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。
在选择装入背包的物品时，对于每种物品i，只能选择装包或不装包，不能装入多次，也不能部分装入，因此成为0-1背包问题。
形式化描述为：给定n个物品，背包容量C >0,重量第i件物品的重量w[i]>0, 价值v[i] >0 , 1≤i≤n.要求找一n元向量(X1,X2,…,X n,), X i∈{0,1}, 使得∑（w[i] * Xi）≤C,且∑ v[i] * Xi达最大.即一个特殊的整数规划问题。
数学描述为：求解最优值：设最优值m(i,j)为背包容量为j、可选择物品为i，i+1，……，n时的最优值(装入包的最大价值)。
所以原问题的解为m(1，C)将原问题分解为其子结构来求解。
要求原问题的解m(1，C)，可从m(n，C)，m(n-1，C)，m(n-2，C).....来依次求解，即可装包物品分别为（物品n）、（物品n-1，n）、（物品n-2，n-1，n）、……、（物品1，物品2，……物品n-1，物品n）。
最后求出的值即为最优值m(1，C)。
若求m(i,j)，此时已经求出m(i+1,j)，即第i+1个物品放入和不放入时这二者的最大值。
对于此时背包剩余容量j=0,1,2,3……C，分两种情况：(1)当w[i] > j，即第i个物品重量大于背包容量j时，m(i,j)=m(i+1,j)(2)当w[i] <= j，即第i个物品重量不大于背包容量j时，这时要判断物品i放入和不放入对m的影响。
若不放入物品i，则此时m(i,j)=m(i+1,j)若放入物品i，此时背包剩余容量为 j-w[i]，在子结构中已求出当容量k=0,1,2……C 时的最优值m(i+1,k)。
所以此时m(i,j)=m(i+1,j-w[i])+v[i]。
背包问题：0-1背包、完全背包和多重背包
背包问题：0-1背包、完全背包和多重背包背包问题泛指以下这⼀种问题：给定⼀组有固定价值和固定重量的物品，以及⼀个已知最⼤承重量的背包，求在不超过背包最⼤承重量的前提下，能放进背包⾥⾯的物品的最⼤总价值。
这⼀类问题是典型的使⽤动态规划解决的问题，我们可以把背包问题分成3种不同的⼦问题：0-1背包问题、完全背包和多重背包问题。
下⾯对这三种问题分别进⾏讨论。
1.0-1背包问题0-1背包问题是指每⼀种物品都只有⼀件，可以选择放或者不放。
现在假设有n件物品，背包承重为m。
对于这种问题，我们可以采⽤⼀个⼆维数组去解决：f[i][j]，其中i代表加⼊背包的是前i件物品，j表⽰背包的承重，f[i][j]表⽰当前状态下能放进背包⾥⾯的物品的最⼤总价值。
那么，f[n][m]就是我们的最终结果了。
采⽤动态规划，必须要知道初始状态和状态转移⽅程。
初始状态很容易就能知道，那么状态转移⽅程如何求呢？对于⼀件物品，我们有放进或者不放进背包两种选择：（1）假如我们放进背包，f[i][j] = f[i - 1][j - weight[i]] + value[i]，这⾥的f[i - 1][j - weight[i]] + value[i]应该这么理解：在没放这件物品之前的状态值加上要放进去这件物品的价值。
⽽对于f[i - 1][j - weight[i]]这部分，i - 1很容易理解，关键是 j - weight[i]这⾥，我们要明⽩：要把这件物品放进背包，就得在背包⾥⾯预留这⼀部分空间。
（2）假如我们不放进背包，f[i][j] = f[i - 1][j]，这个很容易理解。
因此，我们的状态转移⽅程就是：f[i][j] = max(f[i][j] = f[i - 1][j] , f[i - 1][j - weight[i]] + value[i])当然，还有⼀种特殊的情况，就是背包放不下当前这⼀件物品，这种情况下f[i][j] = f[i - 1][j]。
动态规划算法：0-1背包问题
//输出Fibonacii数列的第n项的动态规划算法 #include <stdio.h> #define MAX 50 int fib(int n) { int i,a[MAX]; a[1]=a[2]=1; for (i=3; i<=n; i++) a[i]=a[i-1]+a[i-2]; return a[n]; } void main( ) { int n; scanf("%d",&n); printf("%d\n" ,fib( n ) ); }
动态规划算法原理将待求解的问题分解成若干个相互联系的子问题先求解子问题然后从这些子问题的解得到原问题的解
动态规划算法原理
将待求解的问题分解成若干个相互联系 的子问题，先求解子问题，然后从这些子问 题的解得到原问题的解；对于重复出现的子 问题，只在第一次遇到的时候对它进行求解， 并把答案保存起来。 为了不去求解相同的子问题，引入一个数 组，把所有子问题的解存于该数组中，这就 是动态规划所采用的基本方法。动态规划采 用由下至上(Bottom-Up) 计算策略。
void knapsack() { int i,j; for (j=w[n]; j<=c; j++) m[n][j]=v[n]; for (i=n-1; i>=1;i--) for (j=w[i]; j<=c; j++) if ( m[i+1][j]>m[i+1][j-w[i]]+v[i] ) m[i][j]=m[i+1][j]; else m[i][j]=m[i+1][j-w[i]]+v[i]; }
例：输出Fibonacii数列的第n项的递归算法
0-1背包
0-1背包一、问题描述：给定N种物品和一个背包。
物品i的重量是wi，其价值为vi，背包的容量为C。
问如何选择装入背包中的物品，使得装入背包中物品的总价值最大？二、数据输入：表格一：物品重量与价值三、结果输出：图一：程序运行结果四、算法描述：首先0-1背包问题具有最有子序列性质。
对于每个物品我们可以有两个选择，放或者不放，当有N个物品，就需要进行N次选择，设f[i][v]表示做出第i次选择后，所选物品放入一个容量为v的背包获得的最大价值。
现在有两种选择，放或者不放。
1、如果放入第i件物品，则f[i][v] = f[i-1][v-w[i]]+p[i],表示，前i-1次选择后所选物品放入容量为v-w[i]的背包所获得最大价值为f[i-1][v-w[i]]，加上当前所选的第i 个物品的价值p[i]即为f[i][v]。
2、果不放入第i件物品，则有f[i][v] = f[i-1][v],表示当不选第i件物品时，f[i][v]就转化为前i-1次选择后所选物品占容量为v时的最大价值f[i-1][v]。
既:f[i][v] = max{f[i-1][v], f[i-1][v-wi[i]]+vi[i]}五、算法设计：使用动态规划的方法根据上述算法描述，我们需要循环N次，再循环的过程中就会存在重复的计算，于是我们可以用到动态规划算法，每一次运算时，把之前解出的数据存放起来，用到的时候再拿出来，这样就可以减少运行时间，提高运行效率。
六、举例：引用表格一：当i为1时，首先判断第一个物品的重量是否小于等于背包容量，判断成立，当前背包的价值为5，当前背包容量为3，背包容量大于0，继续放入；当i为2时，判断第二个物品的重量是否小于等于背包容量，判断不行，此时背包的价值为5；当i为3时，判断第三个物品的重量是否小于等于背包容量，判断成立，此时背包的价值为5+7=12，当前背包容量为0；循环结束，找到最大价值。
本问题主要是判断书包能否装下，当找到第i位不能装下时，此时的最大价值就是i-1的位置，当第i为可以放下，就需要第i位的总价值与第i-1位的总价值相比较，放入总价最大的。
动态规划求解01背包问题
动态规划求解01背包问题问题给定n种物品和⼀个背包，物品(1<=i<=n)重量是w I ，其价值v i,背包容量为C,对每种物品只有两种选择：装⼊背包和不装⼊背包，即物品是不可能部分装⼊，部分不装⼊。
如何选择装⼊背包的物品，使其价值最⼤？想法该问题是最优化问题，求解此问题⼀般采⽤动态规划（dynamic plan），很容易证明该问题满⾜最优性原理。
动态规划的求解过程分三部分：⼀：划分⼦问题：将原问题划分为若⼲个⼦问题，每个⼦问题对应⼀个决策阶段，并且⼦问题之间具有重叠关系⼆：确定动态规划函数：根据⼦问题之间的重叠关系找到⼦问题满⾜递推关系式（即动态规划函数），这是动态规划的关键三：填写表格：设计表格，以⾃底向上的⽅式计算各个⼦问题的解并填表，实现动态规划过程。
思路：如何定义⼦问题？0/1背包可以看做是决策⼀个序列（x1,x2,x3,…,xn）,对任何⼀个变量xi的决策时xi=1还是xi=0. 设V(n,C)是将n个物品装⼊容量为C的背包时背包所获得的的最⼤价值，显然初始⼦问题是将前i个物品装如容量为0的背包中和把0个物品装⼊容量为j的背包中，这些情况背包价值为0即V(i,0)=V(0,j)=0 0<=i<=n, 0<=j<=C接下来考虑原问题的⼀部分，设V(I,j)表⽰将前i个物品装⼊容量为j的背包获得的最⼤价值，在决策xi时，已经确定了(x1,x2,…,xi-1)，则问题处于下列两种情况之⼀：1. 背包容量不⾜以装⼊物品i，则装⼊前i-1个物品的最⼤价值和装⼊前i个物品最⼤价值相同，即xi=0，背包价值没有增加2. 背包容量⾜以装⼊物品i，如果把物品i装⼊背包，则背包物品价值等于把前i-1个物品装⼊容量为j-wi的背包中的价值加上第i个物品的价值vi；如果第i个物品没有装⼊背包，则背包价值等于把前i-1个物品装⼊容量为j的背包中所取得的价值，显然，取⼆者最⼤价值作为把物品i装⼊容量为j的背包中的最优解，得到如下递推公式为了确定装⼊背包中的具体物品，从V(n,C)的值向前推，如果V（n，C）>V(n-1,C),则表明第n个物品被装⼊背包中，前n-1个物品被装⼊容量为C-wn的背包中；否则，第n个物品没有被装⼊背包中，前n-1个物品被装⼊容量为C的背包中，依次类推，直到确认第⼀个物品是否被装⼊背包中代码C++实现1. // dp_01Knapsack.cpp : 定义控制台应⽤程序的⼊⼝点。
分支界限法0-1背包问题（优先队列式分支限界法）
分⽀界限法0-1背包问题（优先队列式分⽀限界法）输⼊要求有多组数据。
每组数据包含2部分。
第⼀部分包含两个整数C （1 <= C <= 10000）和 n （1 <= n <= 10，分别表⽰背包的容量和物品的个数。
第⼆部分由n⾏数据，每⾏包括2个整数 wi（0< wi <= 100）和 vi（0 < vi <= 100），分别表⽰第i个物品的总量和价值输出要求对于每组输⼊数据，按出队次序输出每个结点的信息，包括所在层数，编号，背包中物品重量和价值。
每个结点的信息占⼀⾏，如果是叶⼦结点且其所代表的背包中物品价值⼤于当前最优值（初始为0），则输出当前最优值 bestv 和最优解bestx（另占⼀⾏）参见样例输出测试数据输⼊⽰例5 32 23 22 3输出⽰例1 1 0 02 2 2 23 5 2 24 10 4 5bestv=5, bestx=[ 1 0 1 ]4 11 2 23 4 5 42 3 0 0⼩贴⼠可采⽤如下的结构体存储结点：typedef struct{int no; // 结点在堆中的标号int sw; // 背包中物品的重量int sv; // 背包中物品的价值double prior; // 优先值 sv/sw}Node;#include<stdio.h>#include<math.h>#include<string.h>typedef struct {int no; // 结点标号int id; // 节点idint sw; // 背包中物品的重量int sv; // 背包中物品的价值double prior; // sv/sw}Node;int surplusValue(int *v,int n,int y) {int sum = 0;for(int i = y; i <= n; i++) {sum += v[i];}return sum;}void qsort(Node *que,int l,int r) {int len = r - l + 1;int flag;for(int i = 0; i < len; i ++) {flag = 0;for(int j = l; j < l + len - i; j++) {if(que[j].prior < que[j+1].prior) {Node t = que[j];que[j] = que[j+1];que[j+1] = t;flag = 1;}}//if(!flag ) return;}}void branchknap(int *w,int *v,int c,int n) {int bestv = 0;int f = 0;int r = 0;Node que[3000];memset(que,0,sizeof(que));int path[15];que[0].no = 1;que[0].id = que[0].sv = que[0].sw = que[0].prior = 0;while(f <= r) {Node node = que[f];printf("%d %d %d %d\n",node.id+1,node.no,node.sw,node.sv);if(node.no >= pow(2,n)) {if(node.sv > bestv) {bestv = node.sv;printf("bestv=%d, bestx=[",bestv);int temp = node.no;int i = 0;while(temp > 1) {if(temp % 2 == 0)path[i] = 1;elsepath[i] = 0;temp /= 2;i++ ;}i--;while(i >= 0) {while(i >= 0) {printf(" %d",path[i]);i--;}printf(" ]\n");}} else {if((node.sw + w[node.id + 1]) <= c && surplusValue(v,n,node.id+1) + node.sv > bestv) { r++;que[r].id = node.id + 1;que[r].no = node.no*2;int id = node.id + 1;que[r].sv = node.sv + v[id];que[r].sw = node.sw + w[id];que[r].prior = que[r].sv / (que[r].sw*1.0);}if(surplusValue(v,n,node.id+2) + node.sv > bestv) {r++;que[r].id = node.id + 1;que[r].no = node.no*2 + 1;que[r].sv = node.sv;que[r].sw = node.sw;que[r].prior = node.prior;}}f++;qsort(que,f,r);}}int main() {int c,n;int w[15],v[15];while(~scanf("%d %d",&c,&n)){for(int i = 1; i <= n; i++) {scanf("%d %d",&w[i],&v[i]);}branchknap(w,v,c,n);}return 0;}#include<stdio.h>#include<math.h>#include<string.h>typedef int bool;#define true 1#define false 0struct Node{int no; // ?áµ?±êo?int id; //jie dian idint sw; // ±3°ü?D·µá?int sv; // ±3°ü?D·µ?µdouble prior;};struct Node queuee[2000];int w[15],v[15];int bestv = 0,c,n;int path[15]; //lu jingint surplusValue(int y) {int sum = 0;for(int i = y; i <= n; i++)sum += v[i];return sum;}void qsort(int l,int r) {// printf("------\n");int len = r - l + 1;//printf("----%d %d %d-----\n",l,r,len);bool flag;for(int i = 0; i < len ; i++) {flag = false;for(int j = l; j <l+ len -i ;j++) {if(queuee[j].prior < queuee[j+1].prior) {struct Node temp = queuee[j];queuee[j] = queuee[j+1];queuee[j+1] = temp;flag = true;}//if(!flag) return;}}// printf("---排序嘻嘻---\n");//for(int i = l; i <= r;i++ )// printf("***%d : %.2lf\n",queuee[i].no,queuee[i].prior);// printf("\n------\n");}void branchknap() {bestv = 0;int f = 0;int r = 0;queuee[0].no = 1;queuee[0].id = 0;queuee[0].sv = 0;queuee[0].sw = 0;queuee[0].prior = 0;// printf("f: %d r: %d\n",f,r);while(f <= r) {struct Node node = queuee[f];printf("%d %d %d %d\n",node.id+1,node.no,node.sw,node.sv);if(node.no >= pow(2,n)) {if(node.sv > bestv) {bestv = node.sv;//TODOprintf("bestv=%d, bestx=[",bestv);int temp = node.no;int i = 0;while(temp > 1) {if(temp%2 == 0)path[i] = 1;elsepath[i] = 0;temp /= 2;i++;}i--;while(i >= 0) {while(i >= 0) {printf(" %d",path[i]);i--;}printf(" ]\n");}} else {if((node.sw + w[node.id+1]) <= c && surplusValue(node.id+1) + node.sv > bestv) { r++;//printf("%d\n",(node.sw + w[node.id+1]));queuee[r].id = node.id+1;queuee[r].no = node.no*2;int id = node.id+1;queuee[r].sv = node.sv + v[id];queuee[r].sw = node.sw + w[id];queuee[r].prior = queuee[r].sv/(queuee[r].sw*1.0);//printf("进队id： %d\n",queuee[r].no) ;//printf("%d %d %d\n",id,v[id], w[id]);}if(surplusValue(node.id+2) + node.sv > bestv) {r++;queuee[r].id = node.id+1;queuee[r].no = node.no*2 + 1;queuee[r].sv = node.sv ;queuee[r].sw = node.sw ;queuee[r].prior = node.prior;//printf("进队id： %d\n",queuee[r].no) ;}}f++;qsort(f,r);}}int main() {while(~scanf("%d %d",&c,&n)){memset(queuee,0,sizeof(queuee));for(int i = 1; i <= n; i++) {scanf("%d %d",&w[i],&v[i]);}branchknap();}return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(完整word版)0-1背包问题求解方法综述 精彩文档 算法分析与设计大作业
实验题目：0-1背包问题求解方法综述 组 员: 班 级： 指导老师： (完整word版)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背包问题的一些解决方法。 (完整word版)0-1背包问题求解方法综述 精彩文档 为解决背包问题，大量学者在过去的几十年中提出了很多解决方法.解决背包问题的算法有
最优算法和启发式算法［2］,最优算法包括穷举法、动态规划法、分支定界法、图论法等，启发式算法包括贪心算法、遗传算法、蚁群算法、粒子算法等一些智能算法。 0-1背包问题一般描述为:给定n种物品和一个背包。物品i的重量是w（i)，其价值为v(i），背包的容量为c。问应该如何选择装入背包的物品，使得装入背包中的物品的总价值最大? 在选择装入背包的物品时，对每种物品i只有两种选择,即装入背包或不装入背包。不能将物品i装入背包多次,也不能只装入部分的物品i。因此,该问题称为0—1背包问题。 此问题的形式化描述是,给定nivwc
ii1000，，，,要求找出一个n元0—1向量
nixxxxin1}1,0{21，），，，，（，使得
cxwiii
n1，而且iniixv1达到最大。
数学模型：
niiixv1max
约束条件： cxwiiin1， nixi1},1,0{
2。0—1背包问题的求解算法 2.1蛮力算法（brute force method) 2.1.1基本思想： 对于有n种可选物品的0/1背包问题，其解空间由长度为n的0—1向量组成,可用子集数表示.在搜索解空间树时,深度优先遍历,搜索每一个结点，无论是否可能产生最优解，都遍历至叶子结点，记录每次得到的装入总价值,然后记录遍历过的最大价值. 2。1。2代码实现: ＃include #includeusing namespace std； (完整word版)0-1背包问题求解方法综述 精彩文档 #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〈cp＆＆cw+a［i］.w〈=C）{ for （int k=0;k(完整word版)0-1背包问题求解方法综述 精彩文档 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： ”); (完整word版)0-1背包问题求解方法综述 精彩文档 scanf（"％d”,&n)； //输入物品种数
printf（”背包容量C： ”)； scanf(”%d"，&C)； //输入背包容量 for (int i=0；i〈n;i++) //输入物品i的重量w及其价值v { 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〈n;i++) cout〈printf("] 装入总价值％d\n”,sum1); bestP=0,cp=0,cw=0;//恢复初始化 ｝ 2.1。3复杂度分析： 蛮力法求解0/1背包问题的时间复杂度为：2^n 2.2贪心算法（Greedy algorithm） 贪心算法通过一系列的选择来得到问题的解.贪心选择即它总是做出当前最好的选择［4］。贪心选择性质指所求问题的整体最优解可以通过一系列局部最优选择，这是贪心算法与动态规划算法的主要区别。 (完整word版)0-1背包问题求解方法综述 精彩文档 贪心算法每次只考虑一步，每一步数据的选取都必须满足局部最优条件。在枚举剩下数据
与当前已经选取的数据组合获得的解中,提取其中能获得最优解的唯一的一个数据，加入结果数据中,直到剩下的数据不能再加入为止[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]。 单位价值最大者优先：根据价值与重量的比值iv/iw，即单位价值，在剩下的物品中依次
选取比值最大的物品装入背包。这种策略也不能得到最优解。例如：n=3,w=[20,15,15］,v=[40,25,25],iv/iw=[2,5/3,5/3］，c=30,得到的解x=［1,0,0],而最优解是
[0,1,1］。但它是直觉上的一个近似解。本文讨论该策略. 策略3的具体步骤为： 第一步：计算每个物品的价值比ir=iv/iw，i=1,2，…，n。
第二步：对物品的价值比非递增排序。 第三步：重复下面操作，直到有序列表中留下物品。如果列表中的当前物品能够装入背包，就将它放入背包中，否则，处理下一个物品. 2.2。2 编程实现 (完整word版)0-1背包问题求解方法综述 精彩文档 ＃include"stdafx。h”
#include #include〈time.h〉 ＃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〈n；i++） { a［i］=（double)v［i］/w[i]； //单位价值计算 index［i]=i; } for(i=1;i｛ for(int j=0;j｛ if(a[j］〈a[j+1］） //进行循环判断 ｛ double b=a［j]; a[j]=a［j+1］;