实验四 “0-1”背包问题
0-1背包问题
0/1背包问题一、问题描述已知一个容量为M的背包和n件物品，物品编号为0～n-1，第i件物品的重量为w i,若将其装入背包将获益p i。
这里w i＞0, p i ＞0(0≤i＜n)。
所谓的0/1背包问题，是指在物品只能整件装入或不装入的情况下，求一种使得总效益最大的装载方案。
上述问题可形式化描述为：给定M＞0，w i＞0, p i＞0(0≤i＜n)，求一个n元向量x=(x0,x1,…,x n-1),x i∈{0,1}(0≤i＜n)使得∑<≤ni0w i x i≤M且∑<≤nip i x i最大。
为了叙述方便将该问题简记为KNAP(0,n-1,M)。
二、递归法求解1．分析已知x i∈{0,1}，0≤i＜n，假定对x i 作决策的次序是x=(x n-1,x n-2,…,x0),在对x n-1作出决策时存在以下两种情况：(1)x n-1=1，将编号为n-1的物品装入包中，接着求解子问题KNAP(0,n-2,M-w n-1);(2)x n-1=0，不将编号为n-1的物品装入包中，接着求解子问题KNAP(0,n-2,M)。
设f(j,X)是当背包容量为X ，可供选择的物品为0,1,…,j 时的最优解(即最大总效益)，那么f(n-1,M)可表示为：f(n-1,M)=max{f(n-2,M),f(n-2,M-w n-1)+p n-1}对于任意的j ，0≤j ＜n,有f(j,X)=max{f(j-1,X),f(j-1,X-w j )+p j } 若将物品j 装入包中，则f(j,X)= f(j-1,X-w j )+p j反之f(j,X)= f(j-1,X)2．算法(1)f(-1,X)=⎩⎨⎧≥<∞-)0(0)0(X X ；(2)f(j,X)= max{f(j-1,X),f(j-1,X-w j )+p j } 其中0≤j ＜n 。
3．考虑以下背包问题，n=3, (w 0,w 1,w 2)=(2,3,4),(p 0,p 1,p 2)=(1,2,5)和M=6。
0_1背包问题的多种解法
页脚内容1一、 问题描述0/1背包问题:现有n 种物品，对1<=i<=n ，已知第i 种物品的重量为正整数W i ，价值为正整数V i ，背包能承受的最大载重量为正整数W ，现要求找出这n 种物品的一个子集，使得子集中物品的总重量不超过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，且∑=≤+n i i i W y w 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 个物品集合的所有子集，找出所有可能的子集（总重量不超过背包重量的子集），计算每个子集的总重量，然后在他们中找到价值最大的子集。
由于程序过于简单，在这里就不再给出，用实例说明求解过程。
下面给出了4个物品和一个容量为10的背包，下图就是用穷举法求解0-1背包问题的过程。
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个物品看起。
最新实验 4 用分支限界法实现0-1背包问题
实验四用分支限界法实现0-1背包问题一．实验目的1.熟悉分支限界法的基本原理。
2.通过本次实验加深对分支限界法的理解。
二．实验内容及要求内容：.给定n种物品和一个背包。
物品i的重量是w，其价值为v，背包容量为c。
问应该如何选择装入背包的物品，使得装入背包中物品的总价值最大?要求：使用优先队列式分支限界法算法编程，求解0-1背包问题三．程序列表#include<iostream>#include<stack>using namespace std;#define N 100class HeapNode//定义HeapNode结点类{public:double upper, price, weight; //upper为结点的价值上界，price是结点所对应的价值，weight 为结点所相应的重量int level, x[N]; //活节点在子集树中所处的层序号};double MaxBound(int i);double Knap();void AddLiveNode(double up, double cp, double cw, bool ch, int level);//up是价值上界，cp是相应的价值，cw是该结点所相应的重量，ch是ture or falsestack<HeapNode> High; //最大队Highdouble w[N], p[N]; //把物品重量和价值定义为双精度浮点数double cw, cp, c; //cw为当前重量，cp为当前价值，定义背包容量为cint n; //货物数量为int main(){cout <<"请输入背包容量："<< endl;cin >> c;cout <<"请输入物品的个数："<< endl;cin >> n;cout <<"请按顺序分别输入物品的重量："<< endl;int i;for (i = 1; i <= n; i++)cin >> w[i]; //输入物品的重量cout <<"请按顺序分别输入物品的价值："<< endl;for (i = 1; i <= n; i++)cin >> p[i]; //输入物品的价值cout <<"最优值为：";cout << Knap() << endl; //调用knap函数输出最大价值return 0;}double MaxBound(int k) //MaxBound函数求最大上界{double cleft = c - cw; //剩余容量double b = cp; //价值上界while (k <= n&&w[k] <= cleft) //以物品单位重量价值递减装填剩余容量{cleft -= w[k];b += p[k];k++;}if (k <= n)b += p[k] / w[k] * cleft; //装填剩余容量装满背包return b;}void AddLiveNode(double up, double cp, double cw, bool ch, int lev) //将一个新的活结点插入到子集数和最大堆High中{HeapNode be;be.upper = up;be.price = cp;be.weight = cw;be.level = lev;if (lev <= n)High.push(be);}//调用stack头文件的push函数 }double Knap() //优先队列分支限界法，返回最大价值，bestx返回最优解{int i = 1;cw = cp = 0;double bestp = 0; //best为当前最优值double up = MaxBound(1);//价值上界//搜索子集空间树while (1) //非叶子结点{double wt = cw + w[i];if (wt <= c) //左儿子结点为可行结点{if (cp + p[i]>bestp)bestp = cp + p[i];AddLiveNode(up, cp + p[i], cw + w[i], true, i + 1);}up = MaxBound(i + 1);if (up >= bestp) //右子数可能含最优解AddLiveNode(up, cp, cw, false, i + 1);if (High.empty())return bestp;HeapNode node = High.top(); //取下一扩展结点High.pop();cw = node.weight;cp = node.price;up = node.upper;i = node.level;}}四．实验结果酒店服务员年度工作汇报20xx年是自我挑战的一年，我将努力改正过去一年工作中的不足，把新一年的工作做好，过去的一年在领导的关心和同事的热情帮助，通过自身的不懈努力，在工作上取得了一定的成果，现将工作总结如下。
实验四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背包问题算法综述
0-1背包问题是一种常见的动态规划问题，其目标是在给定背包容量和物品集合的情况下，选择某些物品放入背包，使得背包内物品的总价值最大。
以下是求解0-1背包问题的算法综述：
1. 定义变量和参数：
* 物品集合：包括每个物品的重量和价值。
* 背包容量：表示背包能够容纳的最大重量。
* dp数组：用于存储每个状态下的最大价值，dp[i][j]表示前i个物品、背包承重为j时的最大价值。
2. 初始化dp数组：
* 对于每个物品i和背包容量j，如果物品i能够装入背包，则令dp[i][j]为0；否则，令dp[i][j]为负无穷。
3. 递推计算dp数组：
* 对于每个物品i和背包容量j，如果物品i能够装入背包，则令dp[i][j]为当前物品的价值加上前i-1个物品、背包容量为j-w[i]时的最大价值，即dp[i][j] = dp[i-1][j-w[i]] + p[i]；否则，
令dp[i][j]为前i-1个物品、背包容量为j时的最大价值，即dp[i][j] = dp[i-1][j]。
4. 返回dp数组的最后一个元素，即为所求的最大价值。
以上是求解0-1背包问题的算法综述，实际实现时可以根据具体情况进行优化，以提高算法的效率和性能。
0-1背包问题四种不同算法的实现
兰州交通大学数理与软件工程学院题目0-1背包问题算法实现院系数理院专业班级信计09学生姓名雷雪艳学号200905130指导教师李秦二Ｏ一二年六月五日一、问题描述：1、0—1背包问题：给定n 种物品和一个背包，背包最大容量为M ，物品i 的重量是w i ,其价值是平P i ，问应当如何选择装入背包的物品，似的装入背包的物品的总价值最大？ 背包问题的数学描述如下：2、要求找到一个n 元向量(x1，x2…xn)，在满足约束条件：⎪⎩⎪⎨⎧≤≤≤∑10i i i x M w x 情况下，使得目标函数px ii∑max，其中，1≤i ≤n ；M>0；wi>0；pi>0。
满足约束条件的任何向量都是一个可行解，而使得目标函数达到最大的那个可行解则为最优解[1]。
给定n 种物品和1个背包。
物品i 的重量是wi ，其价值为pi ，背包的容量为M 。
问应如何装入背包中的物品，使得装人背包中物品的总价值最大？在选择装人背包的物品时，对每种物品i 只有两种选择，即装入背包、不装入背包。
不能将物品i 装人背包多次，也不能只装入部分的物品i 。
该问题称为0-1背包问题。
0-1背包问题的符号化表示是，给定M>0， w i >0， pi >0，1≤i ≤n ，要求找到一个n 元0-1向量向量(x1，x2…xn)， X i =0 或1 , 1≤i ≤n, 使得Mw xi i≤∑ ，而且px ii∑达到最大[2]。
二、解决方案：方案一：贪心算法1、贪心算法的基本原理与分析贪心算法总是作出在当前看来是最好的选择，即贪心算法并不从整体最优解上加以考虑，它所作出的选择只是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解，但对范围相当广的许多问题它能产生整体最优解。
在一些情况下，即使贪心算法不能得到整体最优解，但其最终结果却是最优解的很好近似解。
贪心算法求解的问题一般具有两个重要性质：贪心选择性质和最优子结构性质。
0-1背包问
实验四：动态规划 0-1背包问题一、 实验目的与要求1、明确0-1背包问题的概念2、利用动态规划解决0-1背包问题问题二、实验题：0-1背包问题(knapsack problem)，某商店有n 个物品，第i 个物品价值为vi ，重量(或称权值)为wi ，其中vi 和wi 为非负数, 背包的容量为W ，W 为一非负数。
目标是如何选择装入背包的物品，使装入背包的物品总价值最大，所选商品的一个可行解即所选商品的序列如何？背包问题与0-1背包问题的不同点在于，在选择物品装入背包时，可以只选择物品的一部分，而不一定要选择物品的全部。
可将这个问题形式描述如下：约束条件为：举例:若商店一共有5类商品，重量分别为：3，4，7，8，9价值分别为：4，5，10，11，13则：所选商品的最大价值为24所选商品的一个序列为：0 0 0 1 1#include <iostream>using namespace std;#define N 6 //物品的个数为N-1，5#define C 11 //背包的容量为C-1，10int max(int number1,int number2); //声明所需函数maxint KnapSack(int w[],int v[]); //声明0/1背包问题算法void main(){int v[N]={0,6,3,5,4,6};int w[N]={0,2,2,6,5,4};cout<<"背包容量为："<<C-1<<endl;cout<<"物品的价值分别是：";for(int j=1;j<=5;j++)∑≤≤n i i i x v 1max }1,0{,1∈≤∑≤≤i n i i i x W x w{cout<<" "<<v[j]<<" ";}cout<<endl;cout<<"物品的重量分别是：";for(int i=1;i<=5;i++){cout<<" "<<w[i]<<" ";}cout<<endl;cout<<"最大价值为：";cout<<KnapSack(w,v)<<endl;}int max(int number1,int number2) //所需函数max{if(number1>number2) return number1;else return number2;}int KnapSack(int w[],int v[]) //0/1背包问题算法{int V[N][C];int x[N];int i;int j;for (i=0;i<=N-1;i++) //初始化第0列{ V[i][0]=0; }for (j=0;j<=C-1;j++) //初始化第0行{ V[0][j]=0; }for(i=1;i<=N-1;i++) //计算第i行，进行第i次迭代{for(j=1;j<=C-1;j++){if(j<w[i])V[i][j]=V[i-1][j];elseV[i][j]=max(V[i-1][j],V[i-1][j-w[i]]+v[i]);}}int k=C-1; //求装入背包的物品for(i=N-1;i>0;i--){if(V[i][k]>V[i-1][k]){x[i]=1;k=k-w[i];}else x[i]=0;}return V[N-1][C-1]; //返回背包取得的最大值}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四“0-1”背包问题
一、实验目的
熟悉C/C++语言的集成开发环境；
通过本实验加深对贪心算法、动态规划算法的理解。
二、实验内容
掌握贪心算法、动态规划算法的概念和基本思想，分析并掌握“0-1”背包问题的求解方法，并分析其优缺点。
三、实验要求
1. “0-1”背包问题的贪心算法
2. “0-1”背包问题的动态规划算法
四、实验步骤
理解算法思想和问题要求；
编程实现题目要求；
上机输入和调试自己所编的程序；
验证分析实验结果；
整理出实验报告。
五、实验程序
#include <stdio.h>
#include "iostream"
using namespace std;
int max(int a,int b)
{
if(a > b)
return a;
else
return b;
}
void ZeroOneBag(int *v,int *w,int *x,int c,int n, int m[8][100])
{
int i,j;
for(j = 0; j < c; j++)
{
if (j < w[n]) //从第N件物品开始，如果放不下
m[n][j]=0;
else //如果放的下
m[n][j]=v[n];
}
for(i = n-1; i >= 1; i--) //控制物品的循环,从i-1到第1件{
for(j = 0; j < w[i]; j++) //贪心法把此行注释
m[i][j]=m[i+1][j]; //贪心法把此行注释
for(j=w[i]; j<=c; j++)
m[i][j]=max(m[i+1][j], m[i+1][j-w[i]]+v[i]);
}
for(i = 1; i < n; i ++) //构造最优解
{
if(m[i][c] == m[i+1][c])
x[i] = 0;
else
{
x[i] = 1;
c = c-w[i];
}
}
x[n] = (m[n][c])?1:0; //m[n][c]大于0吗？大于就是选了return;
}
void main()
{
int i=0,n=7;
int w[]={0,2,3,5,7,1,4,1};
int v[]={0,10,5,15,7,6,18,3};
int x[]={0,0,0,0,0,0,0,0};
cout<<"程序自带数据为："<<"\n";
cout<<"编号重量价值"<<endl;
for ( i=0;i<n;i++)
{
cout<<" "<<i+1<<" "<<w[i+1]<<" "<<v[i+1]<<endl;
}
int m=15;
int array[8][100]={0};
ZeroOneBag(v,w,x,m,7,array);
cout<<"\n背包能装的最大价值为: "<<array[1][m];
cout<<"\n\n最优解为:";
for(i = 1; i <= n; i++)
cout<<" "<<x[i]<<" ";
cout<<"\n\n";
system("pause");
}
六、实验结果
1.贪心法
2.动态规划法
七、实验分析
解决0/1背包问题的方法有多种，最常用的有贪心法和动态规划法。
其中贪心法无法得到问题的最优解，而动态规划法都可以得到最优解。
动态规划算法与分治法类似，其基本思想是将待求解问题分解成若干个子问题，然后从这些子问题的解得到原问题的解。
与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是互相独立的，若用分治法解这类问题，则分解得到的子问题数目太多，以至于最后解决原问题需要耗费过多的时间。
动态规划法又和贪心算法有些一样，在动态规划中，可将一个问题的解决方案视为一系列决策的结果。
不同的是，在贪心算法中，每采用一次贪心准则便做出一个不可撤回的决策，而在动态规划中，还要考察每个最优决策序列中是否包含一个最优子序列。