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。
算法设计与分析实验报告—01背包问题
算法设计与分析实验报告—0/1背包问题-【问题描述】给定n 种物品和一个背包。
物品i 的重量是iw ，其价值为i v，背包容量为C 。
问应该如何选择装入背包的物品，使得装入背包中物品的总价值最大？【问题分析】0/1背包问题的可形式化描述为：给定C>0, i w >0, i v >0,1i n ≤≤，要求找出n 元0/1向量{}12(,,...,),0,1,1n i x x x x i n ∈≤≤，使得n1i i i w x c =≤∑，而且n1i ii v x=∑达到最大。
因此0/1背包问题是一个特殊的整数规划问题。
0n k w ≤≤1max ni i i v x =∑n1i ii w xc =≤∑{}0,1,1i x i n ∈≤≤【算法设计】设0/1背包问题的最优值为m( i, j )，即背包容量是j ，可选择物品为i,i+1,…,n 时0/1背包问题的最优值。
由0/1背包问题的最优子结构性质，可以建立计算m( i, j )的递归式如下：max{m( i+1, j ), m( i+1, j-i w )+i v } i j w ≥m( i, j )=m(i+1,j)n v n j w >m(n,j)=0 0n k w ≤≤【算法实现】#include <iostream.h> #include<string.h> #include<iomanip.h>int min(int w, int c) {int temp; if (w < c) temp = w;elsetemp = c;return temp;}Int max(int w, int c) {int temp; if (w > c) temp = w;elsetemp = c;return temp;}void knapsack(int v[], int w[], int** m, int c, int n) //求最优值 {int jmax = min(w[n]-1, c);for (int j = 0; j <= jmax; j++)m[n][j] = 0;for (int jj = w[n]; jj <= c; jj++)m[n][jj] = v[n];for(int i = n-1; i > 1; i--)//递归部分{jmax = min(w[i]-1, c);for(int j = 0; j <= jmax; j++)m[i][j] = m[i+1][j];for(int jj = w[i]; jj <= c; jj++)m[i][jj] = max(m[i+1][jj], m[i+1][jj-w[i]]+v[i]);}m[1][c] = m[2][c];if(c >= w[1])m[1][c] = max(m[1][c], m[2][c-w[1]]+v[1]);cout << endl << "最优值：" << m[1][c] << endl;cout<<endl;cout<< "&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&" << endl;}int traceback(int x[], int w[], int** m, int c, int n) //回代，求最优解{out << endl << "得到的一组最优解如下: " << endl;for(int i = 1; i < n; i++){if(m[i][c] == m[i+1][c]) x[i] = 0;else{x[i] = 1;c -= w[i];}}x[n] = (m[n][c]) ? 1:0;for(int y = 1; y <= n; y++)cout << x[y] << "\t";cout << endl;return x[n];}void main(){int n, c;int **m;cout << "&&&&&&&&&&&&&&&&&&&&&欢迎使用0-1背包问题程序&&&&&&&&&&&&&&&&&&&" << endl;cout << "请输入物品个数: ";cin >> n ;cout << endl << "请输入背包的承重：";cin >> c;int *v = new int[n+1];cout << endl << "请输入每个物品的价值 (v[i]): " << endl;for(int i = 1; i <= n; i++)cin >> v[i];int *w = new int[n+1];cout << endl << "请输入每个物品的重量 (w[i]): " << endl;for(int j = 1; j <= n; j++)cin >> w[j];int *x = new int[n+1];m = new int* [n+1]; //动态的分配二维数组for(int p = 0; p < n+1; p++)m[p] = new int[c+1];knapsack (v, w, m, c, n);traceback(x, w, m, c, n);}【运行结果】。
01背包实验报告
算法设计与分析实验报告0_1背包一．问题描述假设有n件物品，每件物品有各自的重量W1,W2,……,Wn和与之对应的价值V1,V2,……,Vn。
设背包的容量为c，在不超过背包容量的前提下，求出获得最大价值总和的方案。
（0-1背包的情况下物品不可分割，只能选择放入，或者不放入背包中）。
二．求解思路1.贪心策略问题开始阶段，将所有物品按价值从高到低排列，每一次往背包里放入不超过背包容量的价值最大的物品，直到没有物品可放入为止。
但事实证明，由于物品的不可分割性，0-1背包并不适合贪心策略。
例：假设背包的容量为50，共有三件物品(重量,价值)：（10，60），（20，100），（30，120）。
若使用贪心策略，则会选择一个（30，120）和一个（20，100）。
得到的价值总和是220。
而稍加计算便可知选取两个(20，100)和一个（10，60）可以得到更大的价值总和260。
因此贪心策略不能给出0-1背包的最优解。
后话：即使是普通背包问题（物品可分割），每次选择价值最大的物品也不能得到最优解。
正确的贪心策略应是：每次选择单位重量下价值最大的物品。
由于本次实验主要讨论的是0-1背包问题，这里就不给出该贪心策略的证明。
2.动态规划(1)证明0-1背包问题具有最优子结构性质：假设(x1,x2,……,xn)是容量为c的背包的一组最优解，其中xi的取值为0或1，表示是否放入背包中。
则必有（x2,x3,……,xn）为如下子问题的一组最优解：sum{xi*wi} (2<=i<=n)<=c-x1*w1利用反证法证明，假设（y1,y2,……,yn）是该子问题的一组最优解而（x2,x3,……,xn）不是。
则sum{yi*vi} > sum{xi*vi} (2<=i<=n)那么就可得到:x1*v1+ sum{yi*vi} > x1*v1+ sum{xi*vi} (2<=i<=n)则(x1,y2,……,yn)是原问题的最优解，而(x1,x2,……,xn)不是，与假设矛盾。
实验四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背包问题算法分析背包问题又称子集合问题,最早是由Dantzing 于20世纪50年代首次提出的,已成为计算机学科中一个经典的NP 问题 . 0－1背包问题在很多领域都有广泛的应用,很多实际问题都可转换为0－1背包问题，例如下料问题,贷款组合优化决策问题等，0－l 整数线性规划问题可以归结为0－1背包问题,而整数线性规划问题都可以转化为0－l 整数线性规划问题。
所以,对0－1背包问题求解方法的研究无论是在理论上还是在实践中都具有一定的意义。
一 0－1 背包问题的数学模型及其分类0－1 背包问题的数学模型如下：假设n 个物件,其重量用w i 表示,价值为p i （i ＝1，2，…， n ），背包的最大容纳重量为c,当物件i 被选入背包时,定义变量 x i ＝1，否则 x i ＝0。
现在考虑 n 个物件的选择与否,则背包内 n 个物件总重量为Σw i x i ，物件的总价值为Σp i x i ，如何决定变量x i （i ＝1，2，…，n ）的值（即确定一个物件组合）使背包内物件总价值为最大，其数学模型表示如下：{ 0..max 11≤∑∑==i n i i i n i i x w t s x p到目前为止，求解0－1背包问题的方法很多,精确算法有分支限界法,动态规划法等,近似算法有贪婪方法、蚁群算法等。
一般来说，精确算法不能在较短时间内求解大规模0－1背包问题,使其实用性受到限制。
而近似算法只能求解问题的近似解，有时所得的近似解质量很低。
本文主要针对常见的求解0－1背包问题的算法设计方法进行阐述.二算法思想描述及其性能分析1 分支界限法第一个基于分支界限法的背包问题求解是由Horowit znd Sahni,Nauss and Martello and T oth 于20世纪70年代提出.分支界限法的基本思想是对有约束条件的最优化问题的所有可行解(数目有限)空间进行搜索.该算法在具体执行时,把全部可行的解空间不断分割为越来越小的子集(成为分支),并为每个子集内的解的值计算一个下界或上界(称为定界).在每次分支后,对凡是界限超出已知可行解值的那些子集不再做进一步分支.这样,解的许多子集(即搜索树上的许多结点)就可以不予考虑了,从而缩小了搜索范围.这一过程一直进行到找出可行解为止,该可行解的值不大于任何子集的界限,因此这种算法一般可以求得最优解.分支界限法是组合优化问题的有效求解方法,对于0－1背包问题,其计算步骤如下所述:(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]; //返回背包取得的最大值}。
背包问题实验报告
0-1背包问题实验报告一：0-1背包问题给定n种物品和一个背包。
物品i的重量是Wi，其价值为Vi，背包的容量为c。
问应如何选择装入背包中的物品，使得装入背包中物品的总价值最大？在选择装入背包的物品时，对每种物品i只有两种选择，装入或者不装入背包。
不能将物品i多次装入，也不能装入部分的物品i。
因此，该问题被称为0-1背包问题。
本次针对0-1背包问题的实验，主要使用动态规划的方法、贪心算法、回溯法以及分支限界法。
测试用例为：n=50，c=1000，每个物品重量为{220,208,198,192,180,180,165,162,160,158,155,130,125,122,120,118,115,110,105,1 01,100,100,98,96,95,90,88,82,80,77,75,73,70,69,66,65,63,60,58,56,50,30,20,15,10,8,5 ,3,1,1}每个物品价值为{80,82,85,70,72,70,66,50,55,25,50,55,40,48,50,32,22,60,30,32,40,38,35,32,25,28 ,30,22,50,30,45,30,60,50,20,65,20,25,30,10,20,25,15,10,10,10,4,4,2,1} 下面将分别谈论。
二：动态规划法1：基本思想:动态规划算法的基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。
其经过分解得到的子问题往往不是相互独立的，可以用一张表来记录所有已解决的子问题的答案，而不论该子问题以后是否会用到。
从而使得子问题避免重复计算。
2：设计步骤：动态规划算法适用于解最优化问题，通常可按以下几步设计：（1）找出最优解的特性，并刻画其结构特征。
（2）递归地定义最优值。
（3）以自底向上的方式计算出最优值。
（4）根据计算最优值时得到的信息，构造最优解。
蚁群算法的0-1背包问题求解研究
蚁群算法的0-1背包问题求解研究提出解决背包问题的蚁群算法思想及求解0-1背包问题问题描述，给出了改进常规的蚁群算法的方法。
标签：背包问题,蚁群算法,问题设计,算法改进1 问题描述0／1背包问题是指有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品且对每一物品，要么选，要么不选，满足被选物品的总重量不超过背包指定的限制重量且达到被选物品的价值总和最大的问题。
如果所有物品的重量之和小于背包的容量，则问题极其简单，所得利益也就是所有物品的价值之和。
2 蚁群算法的思想蚁群算法是模仿真实的蚁群行为而提出的一种模拟进化算法．蚂蚁之间是通过一种称为信息素（Pheromone）的物质传递信息的，蚂蚁在运动过程中能够在经过的路径上留下该种物质，而且能够感知这种物质的存在及其强度，并以此指导自己的运动方向．因此，由大量蚂蚁组成的集体行为便表现出一种信息正反馈现象：某一条路径上走过的蚂蚁越多，该路径上留下的信息素就越多，则后来者选择该路径的概率就越大．蚂蚁个体之间就是通过这种信息素的交流，搜索到一条从蚁巢到食物源的最短路径．3 利用蚁群算法求解0-1背包问题设计设有n个城市，d，（i，J=l，2，…，n）表示城市i和J间的距离，t.ij （t）表示在t时刻城市i和j之间的信息量，以此来模拟实际蚂蚁的分泌物。
设共有m只蚂蚁，用P.ij k表示在t时刻蚂蚁k由城市i转移到城市J的概率，则Pk.ij k（t）由城市i转移到城市J的概率，则τα.ij（t）ηβ.ij （t）∑r∈allowedkτα.ir（t）ηβ.ir（t）j∈allowdk0 otherwise其中，allowedk表示蚂蚁k下一步允许走过的城市的集合，表示路径上的信息量对蚂蚁选择路径所起的作用大小，η，为由城市i转移到城市j的期望程度，例如，可以取η.ij=1/d.ij。
β表示η.ij的作用。
当a=0时，算法就是传统的贪心算法；而当p=O时，就成了纯粹的正反馈的启发式算法。
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背包问题，附上例题（POJ-3624CharmBracelet）
0-1背包问题，附上例题（POJ-3624CharmBracelet）0-1背包问题的题⽬样式有 N 件物品和⼀个容量为 M 的背包。
放⼊第 i 件物品耗费的费⽤是 Wi，得到的价值是 Vi。
求解将哪些物品装⼊背包可使价值总和最⼤。
0-1背包问题关键在于该物品放或不放，即在当前容量为M的的情况下，选择不选择该物品，那么就有⼀个转移⽅程for（i=0 - N） for(j= M - w[i]) dp[i][j] = max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);当前物品为i，当前的背包容量为j，如果不选当前该物品，则选取dp[i-1][j]该值。
如果选择当前物品，则选取dp[i-1][j+w[i]]+v[i]该值，从两个值当中选取⼤的值。
最后在dp[N][]中选出最⼤的，为总和最⼤的答案0-1背包的⽅程优化 上⼀个转移⽅程解法，在时间上已基本⽆法优化，只能在空间上进⾏优化。
从O（NM）-> O（M）转移⽅程变为for(j=M - w[i]) dp[j] = max(dp[j],dp[j-w[i]]+v[i]);下⾯解释⼀下为什么该⽅程可⾏：因为w[i]是个正数，即j+w[i] > j肯定是成⽴的，j <=j 且j <=j+w[i]，所以对于下⼀次循环j+1肯定不会取到j+1之前的值，所以该转移⽅程对后续没有影响，是成⽴的。
最后找出dp[]中最⼤的就⾏给出⼀道0-1背包的例题POJ - 3624 /problem?id=3624 Charm BraceletTime Limit: 1000MS Memory Limit: 65536KTotal Submissions: 40985Accepted: 17828DescriptionBessie has gone to the mall's jewelry store and spies a charm bracelet. Of course, she'd like to fill it with the best charms possible fromthe N (1 ≤ N ≤ 3,402) available charms. Each charm i in the supplied list has a weight W i (1 ≤ W i ≤ 400), a 'desirability' factor D i (1 ≤ D i ≤100), and can be used at most once. Bessie can only support a charm bracelet whose weight is no more than M (1 ≤ M ≤ 12,880).Given that weight limit as a constraint and a list of the charms with their weights and desirability rating, deduce the maximum possible sum of ratings.Input* Line 1: Two space-separated integers: N and M* Lines 2..N+1: Line i+1 describes charm i with two space-separated integers: W i and D iOutput* Line 1: A single integer that is the greatest sum of charm desirabilities that can be achieved given the weight constraintsSample Input4 61 42 63 122 7Sample Output23未优化的代码，提交上去是（Memory Limit Exceeded），因为空间复杂度太⼤1 #include <iostream>2 #include <cstring>3 #include <cstdio>4 #include <algorithm>5using namespace std;6int dp[3500][13000];7int main()8 {9int n , m ;10int w[3500], v[3500];1112while(scanf("%d%d",&n,&m) != EOF) {13for(int i= 1 ; i <= n ; i++)14 scanf("%d%d",&w[i],&v[i]);15for(int i = 1 ; i <= n; i++) {16for(int j = 0; j <= m; j++) {17if(j+w[i] <= m)18 dp[i][j] = max(dp[i-1][j],dp[i-1][j+w[i]]+v[i]);19else dp[i][j] = dp[i-1][j];20 }21 }22int ans =0;23for(int j = 0; j <= m; j++)24 ans = dp[n][j] > ans ? dp[n][j]:ans;25 printf("%d\n",ans);26 }27return0;28 }下⾯给出优化的代码（accpeted）1 #include <iostream>2 #include <cstring>3 #include <cstdio>4 #include <algorithm>5using namespace std;6int dp[13000];7int main()8 {9int n , m ;10int w[3500], v[3500];1112while(scanf("%d%d",&n,&m) != EOF) {13for(int i= 1 ; i <= n ; i++)14 scanf("%d%d",&w[i],&v[i]);15for(int i = 1 ; i <= n; i++) {16for(int j = 0; j <= m; j++) {17if(j+w[i] <= m)18 dp[j] = max(dp[j],dp[j+w[i]]+v[i]);19else dp[j] = dp[j];20 }21 }22int ans =0;23for(int j = 0; j <= m; j++)//24 ans = dp[j] > ans ? dp[j]:ans;25 printf("%d\n",ans);26 }27return0;28 }。
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背包问题
1.实验目的（结出本次实验所涉及并要求掌握的知识点）利用动态规划策略解决0-1背包和完全背包问题2.实验内容（结出实验内容具体描述）（1）0-1 Knapsack Problem和Unbounded Knapsack Problem的算法进行实现（2）对0-1Knapsack Problem的算法进行空间优化，使其空间复杂度达到O(W)3.算法描述及实验步骤（用适当的形式表达算法设计思想与算法实现步骤）1. 二维数组的0-1背包空间O(nW)int record[100][100]; // 0-1 背包的二维表void ZO_knapsack_1(int num,int room){// 针对每一个物品进行筛选，看他是否是构成最终max的组成int i,j;for(i=0;i<=num;i++)for(j=0;j<=room;j++)record[i][j]=0; // 初始化record表for(i=1;i<=num;i++){for(j=0;j<=room;j++){if(a[i][0]>j)record[i][j]=record[i-1][j];else{if(record[i-1][j-a[i][0]]+a[i][1]>record[i-1][j])record[i][j]=record[i-1][j-a[i][0]]+a[i][1];elserecord[i][j]=record[i-1][j];}}}}int arry[100]; // 一维记录表int carry[100]; // 是否拿走该物品记录void ZO_knapsack_2(int num,int room){int i,j;for(i=0;i<=num;i++)arry[i]=0; // 初始化arry表for(i=1;i<=num;i++){for(j=room;j>=a[i][0];j--){ //逆序记录if(arry[j-a[i][0]]+a[i][1]>arry[j])arry[j]=arry[j-a[i][0]]+a[i][1];}}3. 一维数组实现完全背包空间：O(W)void UNbounded(int num,int room){int i,j;for(i=0;i<=num;i++)arry[i]=0; // 初始化arry表for(i=1;i<=num;i++){for(j=a[i][0];j<=room;j++){ //顺序记录if(arry[j-a[i][0]]+a[i][1]>arry[j])arry[j]=arry[j-a[i][0]]+a[i][1];}}}4.调试过程及运行结果（详细记录在调试过程中出现的问题及解决方法。
背包问题问题实验报告(3篇)
第1篇一、实验目的1. 理解背包问题的基本概念和分类。
2. 掌握不同背包问题的解决算法，如0-1背包问题、完全背包问题、多重背包问题等。
3. 分析背包问题的复杂度，比较不同算法的效率。
4. 通过实验验证算法的正确性和实用性。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm4. 实验数据：随机生成的背包物品数据三、实验内容1. 0-1背包问题（1）问题描述：给定n个物品，每个物品的重量为w[i]，价值为v[i]，背包的容量为C。
求将哪些物品装入背包，使得背包内物品的总价值最大。
（2）解决算法：动态规划法（3）实验步骤：a. 初始化一个二维数组dp[n+1][C+1]，其中dp[i][j]表示前i个物品在容量为j 的背包中的最大价值。
b. 遍历每个物品，对于每个容量，根据物品的重量和价值计算dp值。
c. 返回dp[n][C]，即为最大价值。
2. 完全背包问题（1）问题描述：给定n个物品，每个物品的重量为w[i]，价值为v[i]，背包的容量为C。
求将哪些物品装入背包，使得背包内物品的总价值最大，且每个物品可以重复取。
（2）解决算法：动态规划法（3）实验步骤：a. 初始化一个一维数组dp[C+1]，其中dp[j]表示容量为j的背包的最大价值。
b. 遍历每个物品，对于每个容量，根据物品的重量和价值更新dp值。
c. 返回dp[C]，即为最大价值。
3. 多重背包问题（1）问题描述：给定n个物品，每个物品的重量为w[i]，价值为v[i]，背包的容量为C。
每个物品有无限个，求将哪些物品装入背包，使得背包内物品的总价值最大。
（2）解决算法：动态规划法（3）实验步骤：a. 初始化一个一维数组dp[C+1]，其中dp[j]表示容量为j的背包的最大价值。
b. 遍历每个物品，对于每个容量，根据物品的重量和价值更新dp值。
c. 返回dp[C]，即为最大价值。
四、实验结果与分析1. 0-1背包问题实验结果显示，在背包容量为100时，最大价值为298。
0_1背包问题算法分析与研究
背包问题的研究在理论研究及应用领域都具有 十分重要的意义。 自 20 世纪 50 年代起就有人提出了 该问题的解决方法，之后便有更多更好的算法层出不 穷。 通过以上的分析，我们可以总结：
●分支界限法：适合于问题规模很小，但协同系 数改变，问题显得更困难的情况，不足是如果在最差 情况下，时间复杂度增大；
（2）动态规划法(Dynamic Programming)
动 态 规 划 法 在 背 包 问 题 的 应 用 是 由 Gilmore 和
Gomony 提出。
动态规划的基本思想：将一个比较大的问题逐层
分解成相对比较小的问题,这些较小的问题一般都可
以解决, 并且利用了最优子结构, 由下向上的方法从
子问题的最优解一步一步地构造出整个问题的最优
种群进化越来越接近某一目标。 如果视种群为超空间
的一组点，选择、杂交和变异的过程即是在超空间中
进行点集之间的某种变换，通过信息交换使种群不断
○
研究与开发
变化。 它最初由美国的 J．H Holland 提出。 遗传算法求
解问题的过程为： ①首先生成一组初群体 (假设为 M 个候选解个
体)，称为第 0 代； ②计算群体中各个候选解的适应值； ③如果有候选解满足算法终止条件， 算法终止；
行之有效的决策方法是至关重要的,能够分解成比较
容易解决的子问题, 是决策设计的最佳标准。
（3）近似算法(Approximate Algorithms)
第一个近似算法是基于动态规划法定义的。 其思
想是：如果价值用其他方法衡量，可能减少运行时间，
但它是以解的准确性为代价的。 具体做法：用 Pi/2k 代 替 Pi（i=1，…，n）。 实际上是将 Pi 的最后 k 位删除，如 果我们期望相对误差最大值为 e>0，整数 k 即为满足
遗传算法求解01背包问题
遗传算法求解01背包问题一、问题描述01背包问题属于组合优化问题的一个例子，求解01背包问题的过程可以被视作在很多可行解当中求解一个最优解。
01背包问题的一般描述如下：给定n个物品和一个背包，物品i的重量为W i，其价值为V i，背包的容量为C。
选择合适的物品装入背包，使得背包中装入的物品的总价值最大。
注意的一点是，背包内的物品的重量之和不能大于背包的容量C。
在选择装入背包的物品时，对每种物品i只有两种选择：装入背包或者不装入背包，即只能将物品i装入背包一次。
称此类问题为0/1背包问题。
01背包问题是NP问题，传统的解决方法有动态规划法、分支界限法、回溯法等等。
传统的方法不能有效地解决01背包问题。
遗传算法（Genetic Algorithms）则是一种适合于在大量的可行解中搜索最优（或次优）解的有效算法。
二、遗传算法1、遗传算法的基本思想遗传算法的搜索从一个被称作种群的候选解集开始，新的种群由旧的种群中产生以期得到更好的种群。
从旧种群中按照解的适应度来选择解以产生新的解；适应度越大，解被选择生成后代的机率也越大。
这个从已有种群中选择双亲并产生后代的迭代过程持续到遗传算法的停止条件满足为止。
2、遗传算法的基本元素。
遗传算法由以下几个原素组成：由染色体组成的种群，根据适应度进行选择以及交叉产生后代。
三、用遗传算法求解01背包问题1、01背包问题中染色体的表示。
用向量X来表示染色体，X = ｛x1，x2，……，x n｝。
，x i∈｛0,1｝，x i=1表示物品i装入了背包，x i =0表示物品i未装入背包。
每个染色体对应其当前装入背包的物品的总价值和总重量。
背包中物品的中价值代表了该物品的适应度。
程序中定义了这样的一个结构来表示染色体：typedef struct{int Weight; //染色体代表的物品的总重量int Fitness; //染色体代表的物品的价值（适应度）int Gene[NUMG]; //用元素取值于定义域｛0,1｝的数组表示染色体。
#动态规划0-1背包问题空间复杂度优化
#动态规划0-1背包问题空间复杂度优化的0-1背包代码的复杂度：时间复杂度O（n*C）空间复杂度O（n*C）优化思路如下：0-1背包问题：F（n，C）考虑将n个物品放⼊背包为C 的背包，使得价值最⼤。
状态转移⽅程：F（i，c） = max(F(i-1 , c) , v(i)+ F(i-1, c- w(i) )根据状态转移⽅程，第i⾏元素计算只依赖与i-1⾏元素。
理论上我们只需要保持两⾏元素。
如上图，我们初始化后第⼀⾏存放0⾏元素，第⼆⾏存放1⾏元素。
⽽第⼆⾏元素可以之间使⽤不再使⽤的0⾏元素。
发现规律：第⼀⾏⼀直为偶数⾏，第⼆⾏⼀直为奇数⾏，所以我们可以使⽤⼀个⾏数为2的⼆维数组来储存。
代码如下：class Knapsack02{public int knapsack02(int[] w , int [] v, int C){assert(w.length == v.length && C>=0);int n = w.length;if(n == 0 || C==0)return 0;int[][] memo = new int[2][C+1];//第⼀⾏初始化。
for(int i = 0 ; i<=C ; i++)memo[0][i] = (i>=w[0]?v[0]:0);for(int i =1 ; i<n ; i++)for(int j =0 ; j<=C ; j++){memo[i%2][j] = memo[(i-1)%2][j];if(j>=w[i])memo[i%2][j] = (int)Math.max(memo[i%2][j] , v[i]+memo[(i-1)%2][j-w[i]]);}return memo[(n-1)%2][C];}}空间复杂度：O（2*C）继续优化：使⽤的例⼦，将其优化为两⾏。
发现dp[i][j] 只需要上⼀⾏的左边与上⽅的元素，⽽右边的元素并不需要。
回溯法-0-1背包问题
1、问题描述一、0-1背包问题给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，如何选择才能使得物品的总价格最高？2、算法设计思想回溯法3、算法过程描述1.解空间的定义物品有装入和不装入两种状态，设装入为1，不装入为0，例如n=3时，解空间为{（0,0,0），（0,0,1）……（1,1,1）}2.解空间结构的组织使用一棵子集树来表示解空间每一条边的权值代表装或不装（1或0）采用深度优先搜索遍历整个树3.约束条件1）重量不超过背包的容量2）已装入物品的价值Cp+剩余空间装入物品的最大价值r<=最优解bestP注*：最大价值r的求法：假设物品能够分割，运用贪心算法的思想，求出背包理论最大价值r4、算法实现及运行结果#include<stdio.h>int n,c,bestp;//物品的个数，背包的容量，最大价值int p[10000],w[10000],x[10000],bestx[10000];//物品的价值，物品的重量，x[i]暂存物品的选中情况,物品的选中情况void Backtrack(int i,int cp,int cw){ //cw当前包内物品重量，cp当前包内物品价值int j;if(i>n)//回溯结束{if(cp>bestp){bestp=cp;for(i=0;i<=n;i++) bestx[i]=x[i];}}elsefor(j=0;j<=1;j++){x[i]=j;if(cw+x[i]*w[i]<=c){cw+=w[i]*x[i];cp+=p[i]*x[i];Backtrack(i+1,cp,cw);cw-=w[i]*x[i];cp-=p[i]*x[i];}}}int main(){int i;bestp=0;printf("请输入背包最大容量:\n");scanf("%d",&c);printf("请输入物品个数:\n");scanf("%d",&n);printf("请依次输入物品的重量:\n");for(i=1;i<=n;i++)scanf("%d",&w[i]);printf("请依次输入物品的价值:\n");for(i=1;i<=n;i++)scanf("%d",&p[i]);Backtrack(1,0,0);printf("最大价值为:\n");printf("%d\n",bestp);printf("被选中的物品依次是(0表示未选中，1表示选中)\n");for(i=1;i<=n;i++)printf("%d ",bestx[i]);printf("\n");return 0;}5、算法复杂度分析及算法改进时间复杂度为O(2^n)*O(n)(求上界)=O(n2^n)。
实现遗传算法的0-1背包问题【精品毕业设计】(完整版)
实现遗传算法的0-1背包问题求解及其改进学校：学院：专业：姓名：学号：课程名称：指导老师：一、 问题陈述0-1背包问题属于组合优化问题的一个例子，求解0-1背包问题的过程可以被视作在很多可行解当中求解一个最优解。
01背包问题的一般描述如下：给定n 个物品和一个背包，物品i 的重量为Wi ，其价值为Vi ，背包的容量为C 。
选择合适的物品装入背包，使得背包中装入的物品的总价值最大。
注意的一点是，背包内的物品的重量之和不能大于背包的容量C 。
在选择装入背包的物品时，对每种物品i 只有两种选择：装入背包或者不装入背包，即只能将物品i 装入背包一次。
称此类问题为0/1背包问题。
其数学模型为：在满足∑w i x i ≤C n i=1的条件下求解 max ∑v i x i n i=1 ，其中i =1,2,3,4…,n0-1背包问题传统的解决方法有动态规划法、分支界限法、回溯法等等。
传统的方法不能有效地解决0-1背包问题。
遗传算法（Genetic Algorithms ）则是一种适合于在大量的可行解中搜索最优（或次优）解的有效算法。
二、遗传算法分析与实现1、遗传算法概述遗传算法（Genetic Algorithm ）是一类借鉴生物界的进化规律（适者生存，优胜劣汰）演化而来的随机化搜索方法。
算法根据问题的目标函数构造一个适值函数，对一个由多个解（每个解对应一个染色体）构成的和种群进行评估、遗传、选择，经多代繁殖，获得适应值最好的个体作为问题的最优解。
其特点是具有内在的隐并行性和更好的全局寻优能力；采用概率化的寻优方法，能自动获取和指导优化的搜索空间，自适应地调整搜索方向，不需要确定的规则。
遗传算法的这些性质，已被人们广泛地应用于组合优化、机器学习、信号处理、自适应控制和人工生命等领域。
• 遗传算法一般是直接在解空间搜索, 而不像图搜索那样一般是在问题空间搜索, 最后才找到解(如果搜索成功的话)。
• 遗传算法的搜索随机地始于搜索空间的一个点集, 而不像图搜索那样固定地始于搜索空间的初始节点或终止节点, 所以遗传算法是一种随机搜索算法。
0-1背包问题
0-1背包问题一．实验内容分别编程实现动态规划算法和贪心法求0-1背包问题的最优解，分析比较两种算法时间复杂度并验证分析结果。
二．实验目的1、掌握动态规划算法和贪心法解决问题的一般步骤，学会使用动态规划和贪心法解决实际问题；2、理解动态规划算法和贪心法的异同及各自的适用范围。
三．算法描述1、动态规划求0-1背包问题时最重要的就是状态转换公式，如下：(1)V(i,0)=V(0,j)=0(2)1.V(i,j)=V(i-1,j) j<wi2.V(i,j)=max{V(i-1,j) ,V(i-1,j-wi)+vi) } j>wiA:如果第i个物品的重量大于背包的容量，则前i个和前i-1个的最大值相同，物品i不能装入背包；B:如果第i个物品的重量小于背包的容量，会有两种情况：(a)如果把第i个物品装入背包，第i-1个物品没有装wi重量物品的价值加上vi；所以x-pk，否则就会超过背包容量(b)如果第i个物品没有装入背包，则背包中物品价值就等于把前i-1个物品装入容量为j的背包中所取得的价值。
然后取a和b中的最大值。
3、利用贪心算法就是先将个物品按其单位重量的价值排序，然后逐个挑选直到背包所剩容量无法再放任何一个物品为止。
贪的是平均价值最高的，设计算法时用到了快速排序。
四．算法实现（一）动态规划实现0-1背包1.数据结构及函数说明const int a=100;//背包容量。
const int 表示不可改变数值的int常量const int b=200;//物品数量int pk[b+1];//物体重量int wt[b+1];//物体价值int m[b+1][a+1];//记录动态规划表，记录最优值2.源程序代码#include<stdio.h>#include<string.h>#include<time.h>const int a=100;//背包容量。
const int 表示不可改变数值的int常量const int b=200;//物品数量int pk[b+1];//物体重量int wt[b+1];//物体价值int m[b+1][a+1];//记录动态规划表void do0_1(){memset(m,0,sizeof(m));for(int i=1;i<=b;i++)for(int x=1;x<=a;x++){if(x<pk[i]||m[i-1][x]>(m[i-1][x-pk[i]]+wt[i])) m[i][x]=m[i-1][x];else m[i][x]=m[i-1][x-pk[i]]+wt[i];}}int main(){freopen("din.txt","r",stdin);freopen("dout1.txt","w",stdout);for(int j=0;j<20;j++){for(int i=1;i<=b;i++)scanf("%d%d",&pk[i],&wt[i]);//第一个数为pk[i],第二个数为wt[1]do0_1();printf("第%d组累计时间：%lf\n",j+1,(double)clock()/CLOCKS_PER_SEC);printf("总价值：%d\n",m[b][a]);}return 0;}（二）贪心法实现0-1背包问题1.数据结构及函数说明#define g 200//物体个数using namespace std;struct package{int w;//重量int v;//价值double perv;//单位价值};物品结构体2.源程序代码#include<cstdio>#include<algorithm>#include<iostream>#include<ctime>#define g 200using namespace std;struct package{int w;//重量int v;//价值double perv;//单位价值};int totalw;int totalv;package f[g];bool cmp(const package &a,const package &b) {return a.perv>b.perv;}//降序排序void do0_1 (int q){totalw=100;//背包容量totalv=0;sort(f,f+g,cmp);int i=0;while(totalw&&i<g){if(f[i].w>totalw){i++;continue;}totalw-=f[i].w;totalv+=f[i].v;//背包问题和0-1背包问题的区别：背包问题可以把一个物品拆分，最后的total 可能大于等于0，而0-1背包不允许拆分i++;}printf("第%d组累计时间：%lf\n",q,(double)clock()/CLOCKS_PER_SEC);cout<<"总价值："<<totalv<<endl;}int main(){freopen("din.txt","r",stdin);freopen("dout2.txt","w",stdout);for(int j=0;j<20;j++){for(int i=0;i<g;i++){cin>>f[i].w>>f[i].v;f[i].perv=(double)f[i].v/(double)f[i].w;}do0_1(j+1);}return 0;}（三）样例产生程序rand.cpp#include<stdio.h>#include<math.h>#include<stdlib.h>int main(){freopen("din.txt","w",stdout);for(int i=0;i<20;i++) {//一共20组数据for(int j=0;j<400;j++){printf("%d ",rand()%100+1); //每组数据200个样例，每个样例的范围是1-100}printf("\n");}return 0;}五．程序运行结果上图为动态规划法实现0-1背包程序的运行结果，不过本窗口的代表着程序运行成功。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
0-1背包问题算法分析背包问题又称子集合问题,最早是由Dantzing 于20世纪50年代首次提出的,已成为计算机学科中一个经典的NP 问题 . 0－1背包问题在很多领域都有广泛的应用,很多实际问题都可转换为0－1背包问题，例如下料问题,贷款组合优化决策问题等，0－l 整数线性规划问题可以归结为0－1背包问题,而整数线性规划问题都可以转化为0－l 整数线性规划问题。
所以,对0－1背包问题求解方法的研究无论是在理论上还是在实践中都具有一定的意义。
一 0－1 背包问题的数学模型及其分类0－1 背包问题的数学模型如下：假设n 个物件,其重量用w i 表示,价值为p i （i ＝1，2，…， n ），背包的最大容纳重量为c,当物件i 被选入背包时,定义变量 x i ＝1，否则 x i ＝0。
现在考虑 n 个物件的选择与否,则背包内 n 个物件总重量为Σw i x i ，物件的总价值为Σp i x i ，如何决定变量x i （i ＝1，2，…，n ）的值（即确定一个物件组合）使背包内物件总价值为最大，其数学模型表示如下：{ 0..max 11≤∑∑==i n i i i n i i x w t s x p到目前为止，求解0－1背包问题的方法很多,精确算法有分支限界法,动态规划法等,近似算法有贪婪方法、蚁群算法等。
一般来说，精确算法不能在较短时间内求解大规模0－1背包问题,使其实用性受到限制。
而近似算法只能求解问题的近似解，有时所得的近似解质量很低。
本文主要针对常见的求解0－1背包问题的算法设计方法进行阐述.二 算法思想描述及其性能分析1 分支界限法第一个基于分支界限法的背包问题求解是由Horowit znd Sahni,Nauss and Martello and Toth 于20世纪70年代提出.分支界限法的基本思想是对有约束条件的最优化问题的所有可行解(数目有限)空间进行搜索.该算法在具体执行时,把全部可行的解空间不断分割为越来越小的子集(成为分支),并为每个子集内的解的值计算一个下界或上界(称为定界).在每次分支后,对凡是界限超出已知可行解值的那些子集不再做进一步分支.这样,解的许多子集(即搜索树上的许多结点)就可以不予考虑了,从而缩小了搜索范围.这一过程一直进行到找出可行解为止,该可行解的值不大于任何子集的界限,因此这种算法一般可以求得最优解.分支界限法是组合优化问题的有效求解方法,对于0－1背包问题,其计算步骤如下所述:(1) 计算每个节点即解集中部分物品的重量和。
如当前重量超过背包容量w ，则将在该节点下的所有子树删除；(2) 计算上一级分支的所有可能解的价值，如果当前分支的价值比较小或相等则删除。
分支界限法并不用于纯粹的深度优先模式，而是最好优先：选择最优希望达到目标结点的结点优先扩展。
此算法由于从最小下界分支，每次算完限界后，把搜索树上当前所有的叶子结点的界限进行比较，找出限界最小的结点，此结点即为下次分支的结点。
这种决策的优点是检查子问题较少，能较快地求得最佳解。
在最坏情况下，不可避免地要在整个状态空间树上进行搜索，要存储很多叶子结点的限界和对应的耗费矩阵，需要数级的时间复杂度O （n2），此时其空间消耗也较大。
可以说一个分支定界求解方法的效率基本上由值界方法决定，若界估计不好，在极端情况下将于穷举搜索没多大区别。
2 动态规划法动态规划法DM （Dynamic Programming ，简称DM ）是美国 数学家Bellman R E 等人20世纪50年代初在研究阶段决策过程的优化问题时提出的，把多阶段决策过程转化为一系列单阶段决策问题逐个求解，创立了解决这类过程优化问题的新方法—动态规划。
动态规划算法是先把问题分成多个子问题（一般地每个子问题是互相关联和影响的），再依次研究逐个问题的决策。
决策就是某个阶段的状态确定后，从该状态演变到下一阶段状态的选择。
当全体子问题都解决时，整体问题也随之解决。
用枚举的方法从所有可能的决策序列中去选取最优决策序列可能是较费时的笨拙方法，但利用最优性原理去找出递推关系，再找最优决策序列就可能使得枚举数量大大下降，这就是动态规划方法设计算法的主要思路。
设F k （y ）为背包只装前k 种东西，总重限制为y 的情况下所具有的最大价值，即 )0()0(max )(11b y y xw n k x p y F i k i i i ki i k ≤≤≤≤≤=∑∑==这两个式子分别为背包问题子问题的目标函数和约束条件，不难看出是满足优化原则的。
使用动态规划法求解，所得递推公式和边界条件是：F k （y ）＝max （F k －1（y ），F （y －w k ）＋p k ），F 0（y ）＝0，对一切 y ，0≤y ≤c ， F k （y ）＝0，对一切 y ，0≤k ≤n ， F 1（y ）＝[y/w 1]·p 1用动态规划方法求解 0－1 背包问题的过程如下：①将问题分解为若干个子问题（一般每个子问题是相互关联和影响的 ），再依次研究逐个问题的决策，也就是把整个问题的最优解与子 问题的局部最优解用递推等式联系起来；②定义边界条件；③把边界条件代入递推公式，逐步求得最优解。
动态规划算法是一种经典的背包问题求解算法，其原理简单，算法思路清晰易于实现。
动态规划算法虽然高效，但是对于规模较大的问题它并不是一个理想的算法，最重要的原因就是它的维数障碍，即计算和存储量的需要对于状态空间和决策空间的维数的增长呈指数增长关系。
这样惊人的增长速度是计算机难以承受的，这就使得直接的动态规划方法求解规划较大的背包问题发生了困难，且目前尚没有好的解决办法。
3 蚁群算法蚁群算法由意大利学者 Dorigo 等人首先提出，是模仿真实的蚁群行为而提出的一种模拟进化算法。
蚂蚁之间是通过一种称为信息 素（Pheromone ）的物质传递信息的，蚂蚁能够在经过的路径上留下该种物质，而且能够感知这种物质的存在及其强度，并以此来指导自己的运动方向。
因此，由大量蚂蚁组成的集体行为便表现出一种信息正反馈现象：某一条路径上走过的蚂蚁越多，该路径上留下的信息素就越多，则后来者选择该路径的概率就越大。
蚂蚁之间就是通过这种信息素的交流，搜索到一条从蚁巢到食物源的最短路径。
将这一问题的核心运用到背包问题中：在某一物品上聚集的信息素越多，则该物品被选择的概率就越大。
就蚁群算法而言，当处理的数据比较小时，其具有很快的收敛速度 ，而随着数据规模的增大，算法的收敛速度明显降低。
假设有m 只蚂蚁，n ＋1个城市，第o 个城市代表背包，第1～n 个城市代表各个物品。
把第o 个城市看成蚂蚁的寻优起点。
令 n ij ＝p i ／ w i 表示蚂蚁从城市转移到城市的期望程度，这样价值越高同时重量越小的物品对蚂蚁的吸引就越大 。
令 e ij 表示路径中留下的信息素强度。
任一只蚂蚁 k 由城市 i 转移到城市j 的概率可设为：),2,1,0(1n j i n e n e p n j b ija ijb ij a ij k ij ===∑= 其中α表示路径上的信息量对蚂蚁选择路径所起的作用大小，β 为吸引度的重要性。
每只蚂蚁从寻优起点出发只需一步就可到达 1～n 当中任意一个食物源，所以上式中有 （i ＝1，2，…，n ）。
寻优过程由多只蚂蚁进行，当每只蚂蚁以较大的概率选中食物源 j 时，如果有c －Σw i x i ≥0，则变量xj 将加1，否则给从i 到 j 的路径以罚值，以使后续的蚂蚁不再选择本路径。
当所有节点都受罚以后将结束一次求解过程。
然后记录最优解，更新信息素。
更新的公式可为Δe ij ＝Q*w j *x je ij （t ＋1）＝（1－ρ）*e ij （t ）＋Δe ij （i ＝0，j ＝1，2，…，n ）上式 中 ρ 为挥发系数，Q 为正常数，x j 为经过该路径的蚂蚁数量。
用蚁群算法求解 0－1 背包问题的过程如下：①初始化：即将任意两个城市之间的道路上的信息素赋一个初值；②搜索：让若干只蚂蚁根据信息素和距离选择城市；③每到一个新城市，进行信息素局部更新；④所有蚂蚁完成回路后，进行全局信息素更新；⑤记录最优路径，返回步骤②循环直到满足退出条件。
蚁群算法是近年来发展起来的一种随机算法，已经证明可以有效解决背包问题。
但是蚁群算法的收敛性证明尚处于初步阶段，缺乏完善的理论基础。
并且在减少寻优计算量和缩短算法运行时间方面,有待进一步改进。
4 贪婪法贪婪算法通过一系列的选择得到问题的解,在每一次总是做出在当前状态下看来是最好的选择，也就是希望通过局部的最优来达到一个全局的最优。
这种启发式的策略并不总能获得最优解，然而在许多情况下确能达到预期的目的，而且对于很多N－P问题来说,本身就不存在最优解。
对于0－1背包问题来说，贪婪的策略有常用的3种。
每种贪婪策略都采用多步过程来完成背包的装入。
在每一步过程中利用贪婪准则选择一个物品装入背包。
第一种贪婪准则:从剩余的物品中，选出可以装入背包的价值最大的物品，利用这种规则，价值最大的物品首先被装入（假设有足够容量），然后是下一个价值最大的物品，如此继续下去。
第二种贪婪准则：从剩下的物品中选择可装入背包的重量最小的物品，如此继续下去直到不能满足条件为止。
第三种贪婪准则：价值密度（价值重量比p i／w i）贪婪算法，这种选择准则为：从剩余物品中选择可装入包的p i／w i值最大的物品，这也是本文所选择的贪婪策略，因为它是一个直觉上近似的解。
用贪婪算法求解0－1背包问题的过程如下：①对于给定的物品，分别求出价值密度（价值重量比），r i＝p i／w i，i＝1，2，…，n；②忽略先前的物品排序，按照价值密度，进行非升序排列：（p（1）/w（1）≥（p（2）/w （2）≥…≥（p（n）/w (n））；③重复以下步骤，直到不满足条件为止：对于当前的物品，如果重量小于包中剩余的容量，则放入并置物品标志为1（表明被选中），否则就停止。
算法主要耗时是在于将各种物品按价值密度大小排序，本文利用MATLAB软件中的SORTROWS函数进行排序，此函数是基于快速排序（quicksort）实现的，因此算法的时间复杂度为O（nlogn）。
其他算法和各种算法的改进除了以上介绍的算法外，还有DNA算法，人工神经网络，递归，回溯法，克隆选择算法，禁忌搜索与GA算法，混合算法等，由于各种算法都有自身的优点和不足，许多学者通过利用一种算法的有点同时通过结合其他算法避免该算法的不足，出现了混合算法，这些算法都取得了很大成功。
通过计算复杂度的研究表明0－1背包问题是一个经典的NP问题。
对于规模过大的0－1背包问题，人们还是无法找到完美的求解方法，所有智能算法都是在一定范围内求解。