0-1背包问题
0_1背包问题的多种解法
一、 问题描述0/1背包问题:现有n 种物品，对1<=i<=n ，已知第i 种物品的重量为正整数W i ，价值为正整数V i ，背包能承受的最大载重量为正整数W ，现要求找出这n 种物品的一个子集，使得子集中物品的总重量不超过W 且总价值尽量大。
（注意：这里对每种物品或者全取或者一点都不取，不允许只取一部分）二、 算法分析根据问题描述，可以将其转化为如下的约束条件和目标函数：)2(max )1()1}(1,0{11∑∑==⎪⎩⎪⎨⎧≤≤∈≤ni i i ini i i x v n i x Wx w 于是，问题就归结为寻找一个满足约束条件（1），并使目标函数式（2）达到最大的解向量),......,,,(321n x x x x X =。
首先说明一下0-1背包问题拥有最优解。
假设),......,,,(321n x x x x 是所给的问题的一个最优解，则),......,,(32n x x x 是下面问题的一个最优解：∑∑==⎪⎩⎪⎨⎧≤≤∈-≤ni i i ini i i x v n i x x w W x w 2211max )2}(1,0{。
如果不是的话，设),......,,(32n y y y 是这个问题的一个最优解，则∑∑==>n i ni ii ii xv y v 22，且∑=≤+ni iiW yw x w 211。
因此，∑∑∑====+>+ni i i n i n i i i i i x v x v x v y v x v 1221111，这说明),........,,,(321n y y y x 是所给的0-1背包问题比),........,,,(321n x x x x 更优的解，从而与假设矛盾。
穷举法：用穷举法解决0-1背包问题，需要考虑给定n 个物品集合的所有子集，找出所有可能的子集（总重量不超过背包重量的子集），计算每个子集的总重量，然后在他们中找到价值最大的子集。
0-1背包问题
• 因为本题的目标是求解储蓄罐内可以达到的最小金 额，所以初始化时所有dp都为INF(无穷大)，且 dp[0]=0。（如果要求解储蓄罐内可以达到的最大金 额，那么应该初始化为-1）。本题的解为dp[n][m]， 如果dp[n][m]为INF，则说明m克是一个不可达的状 态。
• 本题dp数组一维，下标为硬币重量。
SPACE ELEVATOR
• 试题来源：USACO 2005 March Gold • 在线测试：POJ 2392
• 奶牛们要上太空了！它们计划建造一座太空电梯作 为它们登上太空的轨道：电梯是一个巨大的、由块 组成的塔，有K（1K400）种不同类型的块用于建 造塔。类型i的块的高度为hi（1hi100），块的数量 为ci（1ci10）。由于宇宙射线可能造成的损害，在 塔中，由类型i的块组成的部分不能超过最大高度ai （1ai40000）。
• 由于本题的数据范围较大，而long long可以存 储19位，因此，将超过19位的部分称为高位部 分（如果存在），19位以内的部分称为低位部 分。设两个long long类型的变量dp1[ ]和dp2[ ]， 其中dp1[ ]存储高位部分，dp2[ ]存储低位部分。 这样，就可以按照题目要求的数据规模存储和 输出方式数了。
多重背包
• 多重背包问题描述如下：给定n种物品和一个 载荷能力为M的背包，物品i重量为wi，数量为 numi ， 价 值 为 pi ， 其 中 wi>0 ， pi>0 ， numi>0 ， 1in；求解将哪些物品装入背包，可使得使 背包里所放物品的总重量不超过M，且背包中 物品的价值总和达到最大。
背包问题全类型
背包问题全类型背包问题给定⼀组物品，每种物品都有⾃⼰的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最⾼。
背包问题⼤体都可以⽤上述⽅式进⾏描述，但在具体的问题上有了不同的限制条件，于是便有了各种类型的背包问题。
背包问题可基本分为0-1背包问题、部分背包问题、多重背包问题、完全背包问题四⼤类。
接下从四种问题的解决的核⼼算法可以把部分背包问题单独化为⼀类，其核⼼算法为贪⼼。
其余的三种背包问题都可以⽤动态规划解决。
造成部分背包问题与其他的背包问题最⼤不同的原因是其限定条件的不同，部分1. 部分背包问题限定条件：每件物品可以只选取⼀部分完整问题描述：有 n 件物品，第i件物品重 w[i]，价值为 v[i]，且每件物品可以进⾏分割，分割后的价值按取⾛重量占该物品总重量的⽐值计算。
在不超过最⼤承载量 C 的范围内，问最⼤可以取⾛的价值为多少？( 其中 i ∈ {1,2,3,···,n} )算法：贪⼼分析：根据本题的特殊性，我们可以任意地对某⼀部品进⾏分割，所以我们优先选择性价⽐⾼的物品，即单位重量下物品的价值。
解题代码//C++#include<cstdio>#include<algorithm>#include<iostream>using namespace std;struct bag { int w,v; //w表⽰重量 v表⽰价值 double p; //⽤来储存v/w 性价⽐}a[10005];bool cmp(bag x,bag y) { return x.p > y.p; //性价⽐⾼的物品排在前⾯}int main() {剩余 } } printf('%.2f\n', ans); //输出答案 return 0;}注意计算时注意数据类型在计算“性价⽐”的时候要注意，在C/C++等⼀部分语⾔中存在以下机制 int/int = int ，这样是⽆法计算出⼩数的，需要将其中任意⼀项浮点化即可。
0-1背包问题——回溯法求解【Python】
0-1背包问题——回溯法求解【Python】回溯法求解0-1背包问题：问题：背包⼤⼩ w，物品个数 n，每个物品的重量与价值分别对应 w[i] 与 v[i]，求放⼊背包中物品的总价值最⼤。
回溯法核⼼：能进则进，进不了则换，换不了则退。
（按照条件深度优先搜索，搜到某⼀步时，发现不是最优或者达不到⽬标，则退⼀步重新选择）注：理论上，回溯法是在⼀棵树上进⾏全局搜索，但是并⾮每种情况都需要全局考虑，毕竟那样效率太低，且通过约束+限界可以减少好多不必要的搜索。
解决本问题思路：使⽤0/1序列表⽰物品的放⼊情况。
将搜索看做⼀棵⼆叉树，⼆叉树的第 i 层代表第 i 个物品，若剩余空间允许物品 i 放⼊背包，扩展左⼦树。
若不可放⼊背包，判断限界条件，若后续继续扩展有可能取得最优价值，则扩展右⼦树（即此 i 物品不放⼊，但是考虑后续的物品）。
在层数达到物品的个数时，停⽌继续扩展，开始回溯。
注：如何回溯呢？怎样得到的，怎样恢复。
放⼊背包中的重量取出，加在bagV上的价值减去。
约束条件：放⼊背包中物品的总质量⼩于等于背包容量限界条件：当前放⼊背包中物品的总价值（i及之前） + i 之后的物品总价值 < 已知的最优值这种情况下就没有必要再进⾏搜索数据结构：⽤⼀个变量记录当前放⼊背包的总价值 bagV（已扩展），⼀个变量记录后续物品的总价值 remainV（未扩展），当前已得到的⼀种最优值 bestV（全局情况），⼀个⽤0/1表⽰的数组bestArr[]记录哪些物品放⼊了背包。
核⼼结构：递归思路进⾏解决。
层层递归，递归到尽头，保留最优值，恢复递归中，层层回溯，即将原来加上去的重量与价值恢复。
# -*- coding:utf-8 -*-def Backtrack(t):global bestV, bagW, bagV,arr, bestArr, cntVif t > n: #某次深度优先搜索完成if bestV < bagV:for i in range(1, n+1):bestArr[i] = arr[i]bestV = bagVelse: #深度优先搜索未完成if bagW + listWV[t][0] <= w: #第t个物品可以放⼊到背包中，扩展左⼦树arr[t] = TruebagW += listWV[t][0]bagV += listWV[t][1]Backtrack(t+1)bagW -= listWV[t][0]bagV -= listWV[t][1]if cntV[t] + bagV > bestV: #有搜索下去的必要arr[t] = FalseBacktrack(t+1)if__name__ == '__main__':w = int(input()) #背包⼤⼩n = int(input()) #物品个数listWV = [[0,0]]listTemp = []sumW = 0sumV = 0for i in range(n):listTemp = list(map(int, input().split())) #借助临时list每次新增物品对应的list加⼊到listWV中sumW += listTemp[0]sumV += listTemp[1]listWV.append(listTemp) #依次输⼊每个物品的重量与价值bestV = 0bagW = 0bagV = 0remainV = sumVarr = [False for i in range(n+1)]bestArr = [False for i in range(n+1)]cntV = [0 for i in range(n+1)] #求得剩余物品的总价值,cnt[i]表⽰i+1~n的总价值 cntV[0] = sumVfor i in range(1, n+1):cntV[i] = cntV[i-1] - listWV[i][1]if sumW <= w:print(sumV)else:Backtrack(1)print(bestV)print(bestArr)print(cntV)检测：1052 65 34 52 43 617[False, True, False, True, False, True][24, 18, 15, 10, 6, 0]。
0_1背包问题的多种解法
、问题描述0/1背包问题：现有n种物品，对1<=i<=n，已知第i种物品的重量为正整数W,价值为正整数V，背包能承受的最大载重量为正整数V，现要求找出这n种物品的一个子集，使得子集中物品的总重量不超过W且总价值尽量大。
(注意：这里对每种物品或者全取或者一点都不取，不允许只取一部分)、算法分析根据问题描述，可以将其转化为如下的约束条件和目标函数：nw i x i Wi i ⑴X i {0,1(1 i n)nmax v i x (2)i 1于是，问题就归结为寻找一个满足约束条件( 1)，并使目标函数式(2)达到最大的解向量首先说明一下0-1背包问题拥有最优解假设(X1, X2,X3,……,X n)是所给的问题的一个最优解，则 (X2,X3,……,X n)是下面问题的一个最优解:nWi 2X i {0,1}(2W1X1 maxi n) inv i X。
如果不是的话，设(y2> y3>....2..,y n)是这个问题的一个最优解，则n nV i y i V i X ii 2 i 2，且 W1X1n nW i y i W。
因此，V1X1 V i y ii 2 i 2n nV1X1V j X VX i，这说明i 2 i 1(X1,y2,y3, ....... , y n)是所给的0-1背包问题比(X1,X2,X3, ............ , X n)更优的解，从而与假设矛盾穷举法:用穷举法解决0-1背包问题，需要考虑给定n个物品集合的所有子集，找出所有可能的子集(总重量不超过背包重量的子集)，计算每个子集的总重量，然后在他们中找到价值最大的子集。
由于精品(X1, X2,X3,……X n)。
程序过于简单，在这里就不再给出，用实例说明求解过程。
下面给出了4个物品和一个容量为10的背包，下图就是用穷举法求解0-1背包问题的过程。
(a)四个物品和一个容量为10的背包(b)用回溯法求解0-1背包问题的过程递归法：在利用递归法解决0-1背包问题时，我们可以先从第n个物品看起。
分支界限法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;}。
0-1背包问题-贪心法和动态规划法求解
实验四“0-1”背包问题一、实验目的与要求熟悉C/C++语言的集成开发环境；通过本实验加深对贪心算法、动态规划算法的理解。
二、实验内容:掌握贪心算法、动态规划算法的概念和基本思想，分析并掌握“0-1”背包问题的求解方法，并分析其优缺点。
三、实验题1.“0-1”背包问题的贪心算法2.“0-1”背包问题的动态规划算法说明：背包实例采用教材P132习题六的6-1中的描述。
要求每种的算法都给出最大收益和最优解。
设有背包问题实例n=7，M=15,，(w0,w1,。
w6)=（2,3,5,7,1,4,1），物品装入背包的收益为：（p0，p1，。
，p6）=（10,5,15,7,6,18,3）。
求这一实例的最优解和最大收益。
四、实验步骤理解算法思想和问题要求；编程实现题目要求；上机输入和调试自己所编的程序；验证分析实验结果；整理出实验报告。
五、实验程序// 贪心法求解#include<iostream>#include"iomanip"using namespace std;//按照单位物品收益排序，传入参数单位物品收益，物品收益和物品重量的数组，运用冒泡排序void AvgBenefitsSort(float *arry_avgp,float *arry_p,float *arry_w ); //获取最优解方法，传入参数为物品收益数组，物品重量数组，最后装载物品最优解的数组和还可以装载物品的重量float GetBestBenifit(float*arry_p,float*arry_w,float*arry_x,float u);int main(){float w[7]={2,3,5,7,1,4,1}; //物品重量数组float p[7]={10,5,15,7,6,18,3}; //物品收益数组float avgp[7]={0}; //单位毒品的收益数组float x[7]={0}; //最后装载物品的最优解数组const float M=15; //背包所能的载重float ben=0; //最后的收益AvgBenefitsSort(avgp,p,w);ben=GetBestBenifit(p,w,x,M);cout<<endl<<ben<<endl; //输出最后的收益system("pause");return 0;}//按照单位物品收益排序，传入参数单位物品收益，物品收益和物品重量的数组，运用冒泡排序void AvgBenefitsSort(float *arry_avgp,float *arry_p,float *arry_w ) {//求出物品的单位收益for(int i=0;i<7;i++){arry_avgp[i]=arry_p[i]/arry_w[i];}cout<<endl;//把求出的单位收益排序，冒泡排序法int exchange=7;int bound=0;float temp=0;while(exchange){bound=exchange;exchange=0;for(int i=0;i<bound;i++){if(arry_avgp[i]<arry_avgp[i+1]){//交换单位收益数组temp=arry_avgp[i];arry_avgp[i]=arry_avgp[i+1];arry_avgp[i+1]=temp;//交换收益数组temp=arry_p[i];arry_p[i]=arry_p[i+1];arry_p[i+1]=temp;//交换重量数组temp=arry_w[i];arry_w[i]=arry_w[i+1];arry_w[i+1]=temp;exchange=i;}}}}//获取最优解方法，传入参数为物品收益数组，物品重量数组，最后装载物品最优解的数组和还可以装载物品的重量float GetBestBenifit(float*arry_p,float*arry_w,float*arry_x,float u) {int i=0; //循环变量ifloat benifit=0; //最后收益while(i<7){if(u-arry_w[i]>0){arry_x[i]=arry_w[i]; //把当前物品重量缴入最优解数组benifit+=arry_p[i]; //收益增加当前物品收益u-=arry_w[i]; //背包还能载重量减去当前物品重量cout<<arry_x[i]<<" "; //输出最优解}i++;}return benifit; //返回最后收益}//动态规划法求解#include<stdio.h>#include<math.h>#define n 6void DKNAP(int p[],int w[],int M,const int m); void main(){int p[n+1],w[n+1];int M,i,j;int m=1;for(i=1;i<=n;i++){m=m*2;printf("\nin put the weight and the p:");scanf("%d %d",&w[i],&p[i]);}printf("%d",m);printf("\n in put the max weight M:");scanf("%d",&M);DKNAP(p,w,M,m);}void DKNAP(int p[],int w[],int M,const int m) {int p2[m],w2[m],pp,ww,px;int F[n+1],pk,q,k,l,h,u,i,j,next,max,s[n+1];F[0]=1;p2[1]=w2[1]=0;l=h=1;F[1]=next=2;for(i=1;i<n;i++){k=l;max=0;u=l;for(q=l;q<=h;q++)if((w2[q]+w[i]<=M)&&max<=w2[q]+w[i]){u=q;max=w2[q]+w[i];}for(j=l;j<=u;j++){pp=p2[j]+p[i];ww=w2[j]+w[i];while(k<=h&&w2[k]<ww){p2[next]=p2[k];w2[next]=w2[k];next++;k++;}if(k<=h&&w2[k]==ww){if(pp<=p2[k])pp=p2[k];k++;}else if(pp>p2[next-1]){p2[next]=pp;w2[next]=ww;next++;}while(k<=h&&p2[k]<=p2[next-1])k++;}while(k<=h){p2[next]=p2[k];w2[next]=w2[k];next=next+1;k++;}l=h+1;h=next-1;F[i+1]=next;}for(i=1;i<next;i++)printf("%2d%2d ",p2[i],w2[i]);for(i=n;i>0;i--){next=F[i];next--;pp=pk=p2[next];ww=w2[next];while(ww+w[i]>M&&next>F[i-1]){next=next-1;pp=p2[next];ww=w2[next];}if(ww+w[i]<=M&&next>F[i-1])px=pp+p[i];if(px>pk&&ww+w[i]<=M){s[i]=1;M=M-w[i];printf("M=%d ",M);}else s[i]=0;}for(i=1;i<=n;i++)printf("%2d ",s[i]);}六、实验结果1、贪心法截图：七、实验分析。
动态规划算法0-1背包问题课件PPT
回溯法
要点一
总结词
通过递归和剪枝来减少搜索空间，但仍然时间复杂度高。
要点二
详细描述
回溯法是一种基于递归的搜索算法，通过深度优先搜索来 找出所有可能的解。在0-1背包问题中，回溯法会尝试将物 品放入背包中，并递归地考虑下一个物品。如果当前物品 无法放入背包或放入背包的总价值不增加，则剪枝该分支 。回溯法能够避免搜索一些无效的组合，但仍然需要遍历 所有可能的组合，时间复杂度较高。
缺点
需要存储所有子问题的解，因此空间 复杂度较高。对于状态转移方程的确 定和状态空间的填充需要仔细考虑， 否则可能导致错误的结果。
04
0-1背包问题的动态规划解法
状态定义
状态定义
dp[i][ j]表示在前i个物品中选，总 重量不超过j的情况下，能够获得 的最大价值。
状态转移方程
dp[i][ j] = max(dp[i-1][ j], dp[i1][ j-w[i]] + v[i])，其中w[i]和v[i] 分别表示第i个物品的重量和价值。
02
计算时间复杂度：时间复杂度是指求解问题所需的时间与问题规模之间的关系。对 于0-1背包问题，时间复杂度主要取决于状态总数。由于每个状态都需要被遍历， 因此时间复杂度为O(2^n)，其中n是物品的数量。
03
空间复杂度：空间复杂度是指求解问题所需的空间与问题规模之间的关系。在0-1 背包问题中，空间复杂度主要取决于状态总数。由于每个状态都需要被存储，因此 空间复杂度也为O(2^n)，其中n是物品的数量。
06
0-1背包问题的扩展和实际应用
多多个物品和多个 背包，每个物品有各自的重量和价值， 每个背包有各自的容量，目标是选择物 品，使得在不超过背包容量限制的情况 下，所选物品的总价值最大。
0-1背包问题的近似算法
0-1背包问题的近似算法0-1背包问题的近似算法对问题特点和算法思想做一些整理如下：这类问题其实很有意思，做数学和做计算机的人都会研究，而且我这里将要提到的论文都是做计算机的人所写的。
问题简述0-1 Knapsack Problem （0-1背包问题，下面简称KP）和Subset Sum Problem （子集合加总问题，下面简称SSP）是经典的NP完全问题。
两个问题简要描述如下：KP：有n个物品要放入背包，第i个物品的价值为ci，占据体积为vi，背包的总容积为V，要选择一部分物品放入背包，使得他们的总价值最大。
对应的优化问题是maxxi∑ci∗xis.t.∑vi∗xi≤V,xi∈{0,1}这里xi代表是否选取第i个物品进背包，等于1就代表放入背包，等于0代表不放入背包。
SSP: 给一个集合{c1,c2,…,cn}，还有一个目标值V，问能否选出一个子集，使得子集中元素求和刚好等于V。
我们一般考虑的是他的另一种表述方式：选出一个子集，使得子集中元素求和不超过V，且尽量大。
对应的优化问题是maxxi∑ci∗xis.t.∑ci∗xi≤V,xi∈{0,1}这里xi代表是否选入子集，等于1就是选入子集，等于0就是不选入子集。
SSP是KP的特殊情况，也即当ci=vi的时候，KP退化为SSP，从问题式子上看，也完全一样了。
尽管如此，研究了KP不代表就不用研究SSP了，后面会说明这一点。
精确算法与近似算法这两个问题都有很简单的动态规划算法可以精确求解，但可惜算法的时间复杂度是伪多项式的，也即和V相关，但V不是问题输入数据的规模，n才是。
在ACM竞赛等算法比赛中，经常会遇到一些问题属于KP的变种，而伪多项式算法也就足够了。
由于网上资料很多，而且难度不大，这里就不详细介绍了。
如果你不知道，请你搜索“动态规划求解0-1背包问题”。
这里我们更关心多项式近似算法，也即PTAS（Polynomial Time Approximation Scheme），也即对任意给定的ϵ，算法可以在关于n的多项式时间内求得一个解，且该解和真实最优解的最多相差ϵ倍。
0-1背包问题(回溯法)
0-1背包问题(回溯法)实验报告姓名：学号：指导老师：一．算法设计名称：0-1背包问题（回溯法）二.实验内容问题描述:给定n 种物品和一背包。
物品i 的重量是w i ，其价值为v i ，背包的容量为C 。
问应如何选择装入背包的物品，使得装入背包中物品的总价值最大?在选择装入背包的物品时，对每种物品i 只有两种选择，即装入背包或不装入背包。
不能将物品装入背包多次，也不能只装入部分的物品。
三.实验目的1.运用回溯思想，设计解决上述问题的算法，找出最大背包价值的装法。
2.掌握回溯法的应用四．算法设计：问题求解思路1.由0-1背包问题的最优子结构性质，建立计算m[i][j]的递归式如下：i i i w j w j j i m i v w j i m j i m j i m <≤≥⎩⎨⎧-+---=0],1[]}[],1[],,1[max{),(2.查找装入背包物品的回溯函数：从0-1二叉树的根开始搜索：若是叶子节点，则判断此时的价值是否比当前最优的价值大，否则将之替换，并获得最优解向量且返回；若不是叶子节点，则向左右子树搜索，先改变当前的数据状态，递归的调用自己，然后恢复数据状态表示回溯。
3.边界函数bound主要是当还未搜索到叶子节点时，提前判断其子树是否存可能存在更优的解空间，否则进行回溯，即裁剪掉子树的解空间。
关键数据结构及函数模块：（Backtrack.h ）#ifndef __BACKTRACK_H__#define __BACKTRACK_H__class BP_01_P{public:∑=ni i i x v 1max ⎪⎩⎪⎨⎧≤≤∈≤∑=n i x C x w i n i i i 1},1,0{1BP_01_P(int w,int n):m_Sum_weitht(0),m_Number(0) {m_Sum_weitht=w;m_Number=n;bestHav=0;bestVal=0;curVal=0;curHav=0;m_hav=new int[n];m_val=new int[n];temop=new int[n];option=new int[n];}~BP_01_P(){delete []m_hav;delete []m_val;delete []temop;delete []option;}void traceBack(int n);int bound(int n);void printBestSoulation();int *m_hav;//每个物品的重量int *m_val;//每个物品的价值int *temop;//01临时解int *option;//01最终解int bestHav;//最优价值时的最大重量int bestVal;//最优的价值int curVal;//当前的价值int curHav;//当前的重量private:int m_Sum_weitht;//背包的总容量int m_Number;//物品的种类};#endif __BACKTRACK_H__五：主要的算法代码实现：（Backtrack.cpp）边界函数：bound( )int BP_01_P::bound(int n){int hav_left=m_Sum_weitht-curHav;int bo=curVal;while(n<m_Number && m_hav[n]<=hav_left){hav_left-=m_hav[n];bo+=m_val[n];n++;}if(n<m_Number){bo+=m_val[n]*hav_left/m_hav[n];//bo+=hav_left;}return bo;}回溯递归函数：traceBack( )void BP_01_P::traceBack(int n){if(n>=m_Number){if(curVal>=bestVal){bestVal=curVal;for(int i=0;i<n;i++){option[i]=temop[i];}return ;}}if(curHav+m_hav[n]<=m_Sum_weitht)//向左子树搜索 {curHav=curHav+m_hav[n];curVal=curVal+m_val[n];temop[n]=1;//标记要选择这个物品traceBack(n+1);curHav=curHav-m_hav[n];curVal=curVal-m_val[n];}if(bound(n+1)>bestVal)//向右子树搜索{temop[n]=0;//标记要丢弃这个物品traceBack(n+1);}}主控函数：(main.cpp)#include <iostream>#include "Backtrack.h"using namespace std;int main(){int number,weigth;cout<<"包的总容量:";cin>>weigth;cout<<"物品的种类:";cin>>number;BP_01_P *ptr=new BP_01_P(weigth,number);cout<<"各种物品的重量:"<<endl;for(int i=0;i<number;i++)cin>>ptr->m_hav[i];cout<<"各种物品的价值:"<<endl;for(i=0;i<number;i++)cin>>ptr->m_val[i];ptr->traceBack(0);ptr->printBestSoulation();cout<<"总重量:"<<ptr->bestHav<<"\t总价值:"<<ptr->bestVal<<endl;return 0;}六：算法分析采用回溯法解决0-1背包问题，明显比动态规划法更优良。
0 1背包实验报告
0 1背包实验报告0-1背包实验报告引言：0-1背包问题是在计算机科学中经典的组合优化问题之一。
该问题的目标是在给定一组物品和一个固定容量的背包下，选择一些物品放入背包中，使得放入的物品总价值最大化，同时不能超过背包的容量限制。
本实验旨在通过实际操作和数据分析，深入理解0-1背包问题的求解方法和优化策略。
实验设计：本实验采用Python编程语言进行0-1背包问题的求解。
首先，我们设计了一个物品类(Item)，每个物品具有重量(weight)和价值(value)两个属性。
然后，我们生成了一组具有不同重量和价值的物品，这些物品将作为输入数据用于求解0-1背包问题。
接下来，我们实现了两种常见的求解方法：动态规划和贪心算法，并对它们的性能进行了对比分析。
实验过程：1. 生成输入数据：我们使用随机数生成器生成了一组具有不同重量和价值的物品。
为了方便观察和分析，我们限定了物品的数量为10个，重量范围为1到10，价值范围为1到100。
2. 动态规划求解：动态规划是解决0-1背包问题的经典方法之一。
我们设计了一个动态规划函数，通过填充一个二维数组来求解最优解。
具体步骤如下：- 初始化一个二维数组dp，其中dp[i][j]表示在前i个物品中选择总重量不超过j的物品的最大总价值。
- 通过递推公式dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])求解dp数组。
- 根据dp数组的最后一行最后一列的值，反推出背包中放入的物品。
3. 贪心算法求解：贪心算法是另一种常见的求解0-1背包问题的方法。
它的基本思想是每次选择具有最大单位价值的物品放入背包中，直到背包无法再放入任何物品为止。
具体步骤如下：- 计算每个物品的单位价值(value/weight)。
- 按照单位价值从大到小的顺序对物品进行排序。
- 依次选择单位价值最大的物品放入背包中，直到背包无法再放入任何物品。
0-1背包问题的递归方法
0-1背包问题的递归方法0-1背包问题是一个经典的动态规划问题，可以使用递归方法求解。
定义一个函数`knapsack(weights, values, capacity, n)`，其中`weights`和`values`分别代表物品的重量和价值，`capacity`代表背包的容量，`n`代表当前考虑的物品个数。
递归的思路是对于每个物品，有两种选择：放入背包中或者不放入背包中。
1. 如果第`n`个物品的重量大于背包的容量`capacity`，则不放入背包中，返回`0`；2. 否则，有两种选择：- 选择放入第`n`个物品，则总价值为第`n`个物品的价值加上考虑前`n-1`个物品，背包容量减去第`n`个物品重量的最优解； - 不放入第`n`个物品，则总价值为考虑前`n-1`个物品，背包容量不变的最优解。
代码如下所示：```pythondef knapsack(weights, values, capacity, n):if n == 0 or capacity == 0:return 0if weights[n-1] > capacity:return knapsack(weights, values, capacity, n-1)else:return max(values[n-1] + knapsack(weights, values, capacity-weights[n-1], n-1),knapsack(weights, values, capacity, n-1))```可以通过调用`knapsack`函数来求解0-1背包问题，如下所示：```pythonweights = [2, 3, 4, 5]values = [3, 4, 5, 6]capacity = 5n = len(weights)result = knapsack(weights, values, capacity, n)print(result)```以上代码会输出最优解的总价值。
0-1背包问题(分支限界法)
分支限界法——01背包问题12软工028 胡梦颖一、问题描述0-1背包问题：给定n种物品和一个背包。
物品i的重量是Wi，其价值为Vi，背包的容量为C。
应如何选择装入背包的物品，使得装入背包中物品的总价值最大?在选择装入背包的物品时，对每种物品i只有2种选择，即装入背包或不装入背包。
不能将物品i装入背包多次，也不能只装入部分的物品i。
二、问题分析分支限界法类似于回溯法，也是在问题的解空间上搜索问题解的算法。
一般情况下，分支限界法与回溯法的求解目标不同。
回溯法的求解目标是找出解空间中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。
由于求解目标不同，导致分支限界法与回溯法对解空间的搜索方式也不相同。
回溯法以深度优先的方式搜索解空间，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间。
分支限界法的搜索策略是，在扩展结点处，先生成其所有的儿子结点(分支)，然后再从当前的活结点表中选择下一扩展结点。
为了有效地选择下一扩展结点，加速搜索的进程，在每一个活结点处，计算一个函数值(限界)，并根据函数值，从当前活结点表中选择一个最有利的结点作为扩展结点，使搜索朝着解空间上有最优解的分支推进，以便尽快地找出一个最优解。
这种方式称为分支限界法。
人们已经用分支限界法解决了大量离散最优化的问题。
三．源代码#include <stdio.h>#include<malloc.h>#define MaxSize 100 //结点数的最大值typedef struct QNode{float weight;float value;int ceng;struct QNode *parent;bool leftChild;}QNode,*qnode;typedef struct{qnode Q[MaxSize];int front,rear;}SqQueue; //存放结点的队列SqQueue sq;float bestv=0; //最优解int n=0; //实际物品数float w[MaxSize]; //物品的重量float v[MaxSize]; //物品的价值int bestx[MaxSize]; // 存放最优解qnode bestE;void InitQueue(SqQueue &sq ) //队列初始化{sq.front=1;sq.rear=1;}bool QueueEmpty(SqQueue sq) //队列是否为空{if(sq.front==sq.rear)return true;elsereturn false;}void EnQueue(SqQueue &sq,qnode b) //入队{if(sq.front==(sq.rear+1)%MaxSize){printf("队列已满!");return;}sq.Q[sq.rear]=b;sq.rear=(sq.rear+1)%MaxSize;} qnode DeQueue(SqQueue &sq) //出队{qnode e;if(sq.front==sq.rear){printf("队列已空!");return 0;}e=sq.Q[sq.front];sq.front=(sq.front+1)%MaxSize;return e;}void EnQueue1(float wt,float vt, int i ,QNode *parent, bool leftchild) {qnode b;if (i==n) //可行叶子结点{ if (vt==bestv){ bestE=parent;bestx[n]=(leftchild)?1:0;}return;}b=(qnode)malloc(sizeof(QNode)); //非叶子结点b->weight=wt;b->value=vt;b->ceng=i;b->parent=parent;b->leftChild=leftchild;EnQueue(sq,b);}void maxLoading(float w[],float v[],int c){float wt=0;float vt=0;int i=1; //当前的扩展结点所在的层float ew=0; //扩展节点所相应的当前载重量float ev=0; //扩展结点所相应的价值qnode e=NULL;qnode t=NULL;InitQueue(sq);EnQueue(sq,t); //空标志进队列while (!QueueEmpty(sq)){wt=ew+w[i];vt=ev+v[i];if (wt <= c){if(vt>bestv)bestv=vt;EnQueue1(wt,vt,i,e,true); // 左儿子结点进队列} EnQueue1(ew,ev,i,e,false); //右儿子总是可行；e=DeQueue(sq); // 取下一扩展结点if (e == NULL){if (QueueEmpty(sq))break;EnQueue(sq,NULL); // 同层结点尾部标志e=DeQueue(sq); // 取下一扩展结点i++;}ew=e->weight; //更新当前扩展结点的值ev=e->value;}printf("最优取法为：\n");for( int j=n-1;j>0;j--) //构造最优解{bestx[j]=(bestE->leftChild?1:0);bestE=bestE->parent;}for(int k=1;k<=n;k++){if(bestx[k]==1)printf("物品%d:重量：%.1f，价值：%.1f\n",k,w[k],v[k]);}printf("最大价值为：%.1f\n",bestv);}void main(){int c;float ewv[MaxSize];printf("请输入背包的最大容量v:");scanf("%d",&c);printf("请输入物品总数n:");scanf("%d",&n);printf("请输入物品的重量和单位重量价值:\n");for(int i=1;i<=n;i++){printf("第%d件物品:",i);scanf("%f%f",&w[i],&ewv[i]);v[i]=w[i]*ewv[i];}maxLoading(w,v,c);}五．实验结果。
0-1背包问题的四种写法
0-1背包问题的四种写法本节回顾0-1背包的基本模型，关于它的实现有很多种写法，这⾥对不同实现做个简单列举，主要是写代码练⼿了，主要有以下⼏⽅⾯内容：==0-1背包问题定义 & 基本实现==0-1背包使⽤滚动数组压缩空间==0-1背包使⽤⼀维数组==0-1背包恰好背满==0-1背包输出最优⽅案========================================0-1背包问题定义 & 基本实现问题：有个容量为V⼤⼩的背包，有很多不同重量weight[i](i=1..n)不同价值value[i](i=1..n)的物品，每种物品只有⼀个，想计算⼀下最多能放多少价值的货物。
DP的关键也是难点是找到最优⼦结构和重叠⼦问题，进⽽找到状态转移⽅程，编码就相对容易些。
最优⼦结构保证每个状态是最优的，重叠⼦问题也即n状态的求法和n-1状态的求法是⼀样的；DP在实现上⼀般是根据状态转移⽅程⾃底向上的迭代求得最优解（也可以使⽤递归⾃顶向下求解）。
回到0-1背包，每个物体i，对应着两种状态：放⼊&不放⼊背包。
背包的最优解是在⾯对每个物体时选择能够最⼤化背包价值的状态。
0-1背包的状态转移⽅程为f(i,v) = max{ f(i-1,v), f(i-1,v-c[i])+w[i] }f(i,v)表⽰前i个物体⾯对容量为v时背包的最⼤价值，c[i]代表物体i的cost(即重量)，w[i]代表物体i的价值；如果第i个物体不放⼊背包，则背包的最⼤价值等于前i-1个物体⾯对容量v的最⼤价值；如果第i个物体选择放⼊，则背包的最⼤价值等于前i-1个物体⾯对容量v-cost[i]的最⼤价值加上物体i的价值w[i]。
对于实现，⼀般采⽤⼀个⼆维数组（状态转移矩阵）dp[i][j]来记录各个⼦问题的最优状态，其中dp[i][j]表⽰前i个物体⾯对容量j背包的最⼤价值。
下⾯给出0-1背包的基本实现，时间复杂度为O(N*V)，空间复杂度也为O(N*V)，初始化的合法状态很重要，对于第⼀个物体即f[0][j]，如果容量j⼩于第⼀个物体（编号为0）的重量，则背包的最⼤价值为0，如果容量j⼤于第⼀个物体的重量，则背包最⼤价值便为该物体的价值。
背包问题的各种求解方法
背包问题的各种求解⽅法⼀、“0-1背包”问题描述： 给定n中物品，物品i的重量是w i，其价值为v i，背包的容量为c.问应如何选择装⼊背包中的物品，使得装⼊背包中的物品的总价值最⼤？形式化描述：给定c>0,w i>0,v i>0,1≤i≤n，要求找⼀个n元0-1向量（x1,x2,...,x n)，x i∈{0,1}，1≤i≤n，使得∑w i x i≤c，⽽且∑v i x i达到最⼤。
因此0-1背包问题是⼀个特殊的整形规划问题：max ∑v i x is.t ∑w i x i≤cx i∈{0,1}，1≤i≤n⼆、动态规划求解（两种⽅法，顺序或逆序法求解） 1.最优⼦结构性质 1.1 简要描述 顺序：将背包物品依次从1,2,...n编号，令i是容量为c共有n个物品的0-1背包问题最优解S的最⾼编号。
则S'=S-{i}⼀定是容量为c-w i且有1,...,i-1项物品的最优解。
如若不是，领S''为⼦问题最优解，则V(S''+{i})>V(S'+{i})，⽭盾。
这⾥V(S)=V(S')+v i.逆序：令i是相应问题最优解的最低编号，类似可得。
1.2 数学形式化语⾔形式化的最优⼦结构 顺序（从前往后）：设(y1,y2,...,y n)是所给问题的⼀个最优解。
则(y1,...,y n-1)是下⾯相应⼦问题的⼀个最优解： max ∑v i x is.t ∑w i x i≤cx i∈{0,1}，1≤i≤n-1如若不然，设(z1,...,z n-1)是上述⼦问题的⼀个最优解，⽽(y1,...,y n-1)不是它的最优解。
由此可知，∑v i z i>∑v i y i,且∑v i z i+w n y n≤c。
因此∑v i y i+v n y n>∑v i y i(前⼀个范围是1~n-1，后⼀个是1~n) ∑v i z i+w n y n≤c这说明(z1,z2,...,y n)是⼀个所给问题的更优解，从⽽(y1,y2,...,y n)不是问题的所给问题的最优解，⽭盾。
运筹学背包问题例题
运筹学背包问题例题
运筹学中的背包问题是一个经典的组合优化问题，通常分为0-1背包问题和分数背包问题。
这个问题可以用来描述一个背包有限的容量，以及一系列物品，每个物品都有自己的重量和价值。
问题的目标是找到一个组合，使得放入背包的物品总重量不超过背包容量，同时使得这些物品的总价值最大化。
举一个例子来说明背包问题：假设有一个背包容量为10kg，现有以下物品：
物品A，重量3kg，价值150元。
物品B，重量4kg，价值300元。
物品C，重量5kg，价值200元。
针对这个例子，我们可以用动态规划或者贪心算法来解决背包问题。
在0-1背包问题中，每个物品只能选择放或者不放，不能进行分割。
而在分数背包问题中，物品可以进行分割放入背包。
解决背包问题的关键是建立递推关系和状态转移方程，以确定
如何选择物品放入背包以达到最优解。
动态规划是解决背包问题的
常用方法，通过填写一个二维的状态转移表格来逐步求解最优解。
贪心算法则是通过每一步选择当前最优的策略，不断迭代直至达到
最优解。
除了动态规划和贪心算法，还有其他方法可以解决背包问题，
比如分支限界法、回溯法等。
每种方法都有其适用的场景和局限性。
总的来说，背包问题是运筹学中的一个经典问题，有着广泛的
应用。
通过合适的算法和方法，我们可以有效地解决背包问题，找
到最优的放置方案，这对于资源分配、生产调度等实际问题有着重
要的意义。
0-1背包问题
0-1背包问题背包问题：n种物品，每种物品有重量w和价值v，背包所能承受的最⼤重量为c。
如何挑选物品可以使总物品的价值最⼤。
0-1背包问题：限定每种物品的个数只能是0或1.如：5个物品，质量分别为3,5,7,8,9，价值分别为4,6,7,9,10。
背包所能承受重量为22.给物品从0开始编号，挑选物品1,3,4（价值分别为6,9,10）时，总价值最⼤为25，此时重量为22.运⽤动态规划思想，可以构造有效的⽅法。
算法基本思路：1.构造最优表，获取最⼤价值；构造表mv[0...n][0...c]，mv[i][j] 表⽰前 i 项物品（即0到i-1）中挑选物品放⼊承受重量为 j 的最⼤价值。
显然，当 i 为0即没有物品时，mv[0][*] = 0；当 j 为0即最⼤重量为0时，mv[*][0] = 0。
（*表⽰任意）对于mv[i][j]只有两种可能的情况，（要注意的是，i 表⽰前i 项物品，物品编号从0开始，即 i-1 表⽰第i 项物品）(1)当w[i-1] > j 即当前物品重量⼤于当前最⼤承受重量时，只能放弃当前物品即 mv[i][j] = mv[i-1][j]；(2)当w[i-1] <= j 即当前物品重量⼩于当前最⼤承受重量时，通过⽐较取此物品后的最⼤价值（即mv[i-1][j-w[i-1]] + v[i-1]）与不取此物品的最⼤价值（即mv[i-1][j]），挑出较⼤值即 mv[i][j] = max(mv[i-1][j], mv[i-1][j-w[i-1]])。
通过上述⾃底向上打表，可构造出最优值mv[n][c]。
2.通过最优表，获取构造路线即挑出可以得到最⼤价值的物品。
通过上述可知，当w[i-1] > j 时，mv[i][j] = mv[i-1][j]；当w[i-1] <= j 时，mv[i][j] = max(mv[i-1][j], mv[i-1][j - w[i-1]] + v[i-1])。
部分背包问题的贪心算法正确性证明
部分背包问题的贪⼼算法正确性证明⼀，部分背包问题介绍⾸先介绍下0-1背包问题。
假设⼀共有N件物品，第 i 件物品的价值为 V i，重量为W i，⼀个⼩偷有⼀个最多只能装下重量为W的背包，他希望带⾛的物品越有价值越好，请问：他应该选择哪些物品？0-1背包问题的特点是：对于某件（更适合的说法是：某类）物品，要么被带⾛（选择了它），要么不被带⾛（没有选择它），不存在只带⾛⼀部分的情况。
⽽部分背包问题则是：可以带⾛⼀部分。
即，部分背包问题可带⾛的物品是可以⽆限细分的。
（连续与离散的区别）可以把0-1背包问题中的物品想象的⼀个⾦⼦，你要么把它带⾛，要么不带⾛它；⽽部分背包问题中的物品则是⼀堆⾦粉末，可以取任意部分的⾦粉末⼆，部分背包问题的贪⼼算法部分背包问题可以⽤贪⼼算法求解，且能够得到最优解。
贪⼼策略是什么呢？将物品按单位重量所具有的价值排序。
总是优先选择单位重量下价值最⼤的物品。
单位重量所具有的价值：V i / W i举个例⼦：假设背包可容纳50Kg的重量，物品信息如下：物品 i 重量(Kg) 价值单位重量的价值1 10 60 62 20 100 53 30 120 4按照我们的贪⼼策略，单位重量的价值排序：物品1 > 物品2 > 物品3因此，我们尽可能地多拿物品1，直到将物品1拿完之后，才去拿物品2.....最终贪⼼选择的结果是这样的：物品1全部拿完，物品2也全部拿完，物品3拿⾛10Kg（只拿⾛了物品3的⼀部分）这种选择获得的价值是最⼤的。
在（三）会给出证明。
⽽对于0-1背包问题，如果也按“优先选择单位重量下价值最⼤的物品”这个贪⼼策略，那么，在拿了物品1和物品2之后，就不能在拿物品3了。
因为，在拿了物品1和物品2之后，背包中已经装了10+20=30Kg的物品了，已经装不下物品3了（50-30 < 30）（0-1背包：⼀件物品要么拿，要么不拿，否能只拿⼀部分）,此时得到的总价值是 160。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
// 如果后面的value小于前面则将此物品删除 if (m + 1 <= p.size() - 1) if (((Item) p.get(m)).getValue() >= ((Item) p.get(m + 1)) .getValue()) { p.remove(m + 1); m = 0; } if (((Item) p.get(m)).getWeight() > 10) { p.remove(m); m = 0; } } } } uckSack { public static void main(String[] args) { LinkedList<Item> wuPinList = new LinkedList<Item>(); wuPinList.add(new Item(2, 6)); wuPinList.add(new Item(2, 3)); wuPinList.add(new Item(6, 5)); wuPinList.add(new Item(5, 4)); wuPinList.add(new Item(4, 6)); LinkedList p = new LinkedList(); p.add(new Item(0, 0)); for (int i = 4; i >= 0; i--) { method_get(p, wuPinList.get(i)); System.out.println("p" + (i + 1)); for (int ii = 0; ii < p.size(); ii++) System.out.println((Item) p.get(ii)); } } // 用来计算添加物品的最优解 private static void method_get(LinkedList p, Item pin) { LinkedList q = new LinkedList(); // 计算得到q 即p的每一项加上w for (int i = 0; i < p.size(); i++) { q.add(new Item(((Item) p.get(i)).getWeight() + pin.getWeight(), ((Item) p.get(i)).getValue() + pin.getValue())); } // 求p n-1 即将p n 和q n合并 for (int m = 0; m < q.size(); m++) { p.add((Item) q.get(m)); } Collections.sort(p);// 将背包中的物品按照重量排序 // 去掉跳跃点 for (int m = 0; m < p.size(); m++) {
package pers.menix.algorithm; /* * 0-1背包问题 * 问题描述：给定n种物品和一背包。物品i的重量是w(i)，其价值为 v(i)，背包的容量为C。 * 问:应如何选择装入背包的物品，使得装入背包中物品的总价值最大? * * author：menix * */ import java.util.*; class Item implements Comparable { private int weight; private int value; public Item(int weight, int value) { this.weight = weight; this.value = value; } public int getValue() { return value; } public int getWeight() { return weight; } public int compareTo(Object o) { Item obj = (Item) o; return this.weight > obj.getWeight() ? 1 : (this.weight == obj .getWeight() ? 0 : -1); } public String toString() { return "物品 ： weight=" + weight + ", value=" + value; }