算法设计实验_贪心算法背包问题
贪心算法-01背包问题
贪⼼算法-01背包问题1、问题描述：给定n种物品和⼀背包。
物品i的重量是wi，其价值为vi，背包的容量为C。
问:应如何选择装⼊背包的物品，使得装⼊背包中物品的总价值最⼤?形式化描述：给定c >0, wi >0, vi >0 , 1≤i≤n.要求找⼀n元向量(x1,x2,…,xn,), xi∈{0,1}, ∋ ∑ wi xi≤c,且∑ vi xi达最⼤.即⼀个特殊的整数规划问题。
2、最优性原理：设(y1,y2,…,yn)是 (3.4.1)的⼀个最优解.则(y2,…,yn)是下⾯相应⼦问题的⼀个最优解:证明:使⽤反证法。
若不然,设(z2,z3,…,zn)是上述⼦问题的⼀个最优解,⽽(y2,y3,…,yn)不是它的最优解。
显然有∑vizi > ∑viyi (i=2,…,n)且 w1y1+ ∑wizi<= c因此 v1y1+ ∑vizi (i=2,…,n) > ∑ viyi, (i=1,…,n)说明(y1,z2, z3,…,zn)是(3.4.1)0-1背包问题的⼀个更优解,导出(y1,y2,…,yn)不是背包问题的最优解,⽭盾。
3、递推关系：设所给0-1背包问题的⼦问题的最优值为m(i，j)，即m(i，j)是背包容量为j，可选择物品为i，i+1，…，n时0-1背包问题的最优值。
由0-1背包问题的最优⼦结构性质，可以建⽴计算m(i，j)的递归式:注:(3.4.3)式此时背包容量为j，可选择物品为i。
此时在对xi作出决策之后,问题处于两种状态之⼀:(1)背包剩余容量是j,没产⽣任何效益；(2)剩余容量j-wi,效益值增长了vi ；使⽤递归C++代码如下：#include<iostream>using namespace std;const int N=3;const int W=50;int weights[N+1]={0,10,20,30};int values[N+1]={0,60,100,120};int V[N+1][W+1]={0};int knapsack(int i,int j){int value;if(V[i][j]<0){if(j<weights[i]){value=knapsack(i-1,j);}else{value=max(knapsack(i-1,j),values[i]+knapsack(i-1,j-weights[i]));}V[i][j]=value;}return V[i][j];}int main(){int i,j;for(i=1;i<=N;i++)for(j=1;j<=W;j++)V[i][j]=-1;cout<<knapsack(3,50)<<endl;cout<<endl;}不使⽤递归的C++代码：简单⼀点的修改//3d10-1 动态规划背包问题#include <iostream>using namespace std;const int N = 4;void Knapsack(int v[],int w[],int c,int n,int m[][10]);void Traceback(int m[][10],int w[],int c,int n,int x[]);int main(){int c=8;int v[]={0,2,1,4,3},w[]={0,1,4,2,3};//下标从1开始int x[N+1];int m[10][10];cout<<"待装物品重量分别为："<<endl;for(int i=1; i<=N; i++){cout<<w[i]<<" ";}cout<<endl;cout<<"待装物品价值分别为："<<endl;for(int i=1; i<=N; i++){cout<<v[i]<<" ";}cout<<endl;Knapsack(v,w,c,N,m);cout<<"背包能装的最⼤价值为："<<m[1][c]<<endl;Traceback(m,w,c,N,x);cout<<"背包装下的物品编号为："<<endl;for(int i=1; i<=N; i++){if(x[i]==1){cout<<i<<" ";}}cout<<endl;return 0;}void Knapsack(int v[],int w[],int c,int n,int m[][10]){int jMax = min(w[n]-1,c);//背包剩余容量上限范围[0~w[n]-1] for(int j=0; j<=jMax;j++){m[n][j]=0;}for(int j=w[n]; j<=c; j++)//限制范围[w[n]~c]{m[n][j] = v[n];}for(int i=n-1; i>1; i--){jMax = min(w[i]-1,c);for(int j=0; j<=jMax; j++)//背包不同剩余容量j<=jMax<c{m[i][j] = m[i+1][j];//没产⽣任何效益}for(int j=w[i]; j<=c; j++) //背包不同剩余容量j-wi >c{m[i][j] = max(m[i+1][j],m[i+1][j-w[i]]+v[i]);//效益值增长vi }}m[1][c] = m[2][c];if(c>=w[1]){m[1][c] = max(m[1][c],m[2][c-w[1]]+v[1]);}}//x[]数组存储对应物品0-1向量,0不装⼊背包，1表⽰装⼊背包void Traceback(int m[][10],int w[],int c,int n,int x[]){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;}运⾏结果：算法执⾏过程对m[][]填表及Traceback回溯过程如图所⽰：从m(i，j)的递归式容易看出，算法Knapsack需要O(nc)计算时间; Traceback需O(n)计算时间；算法总体需要O(nc)计算时间。
背包算法问题
背包问题贪心方法 实验日志实验题目：1）求以下情况背包问题的最优解：n=7，M=15，（71,,p p ）=（10，5，15，7，6，18，3）和（71,,w w ）=（2，3，5，7，1，4，1）。
实验目的：1. 掌握贪心方法算法思想；2. 熟练使用贪心算法之背包问题解决相应的问题。
实验思想：贪心方法是一种改进了的分级处理方法。
它首先根据题意，选取一种量度标准。
然后按这种量度标准对这n 个输入排序，并按排序一次输入一个量。
如果这个输入和当前已构成在这种量度意义下的部分最优解加在一起不能产生一个可行解，则不把此解输入加到这部分解中。
这种能够得到某种度量意义下的最优解的分级处理方法称为贪心方法。
1．背包问题（1）背包问题的描述：已知有n 种物品和一个可容纳M 重量的背包，每种物品i 的重量为i w 。
假定将物品i 的一部分i x 放入背包就会得到i i x p 的效益，这里，10≤≤i x , 0>i p 。
显然，由于背包容量是M ，因此，要求所有选中要装入背包的物品总重量不得超过M.。
如果这n 件物品的总重量不超过M ，则把所有物品装入背包自然获得最大效益。
现需解决的问题是，这些物品重量的和大于M ，该如何装包。
由以上叙述，可将这个问题形式表述如下：极 大 化∑≤≤n i i x p 1i约束条件 M x w n i i ≤∑≤≤1in i w p x i i i ≤≤>>≤≤1,0,0,10（2）用贪心策略求解背包问题首先需选出最优的量度标准。
不妨先取目标函数作为量度标准，即每装入一件物品就使背包获得最大可能的效益值增量。
在这种量度标准下的贪心方法就是按效益值的非增次序将物品一件件放到背包中去。
如果正在考虑中的物品放不进去，则可只取其一部分来装满背包。
但这最后一次的方法可能不符合使背包每次获得最大效益增量的量度标准，这可以换一种能获得最大增量的物品，将它（或它的一部分）放入背包，从而使最后一次装包也符合量度标准的要求。
经典贪心题
贪心算法是一种在解决问题的过程中追求局部最优的算法，对于一个有多种属性的事物来说，贪心算法会优先满足某种条件，追求局部最优的同时希望达到整体最优的效果。
以下是一些经典的贪心算法问题：1. 背包问题：给定一组物品，每个物品都有自己的重量和价值，背包的总容量有限。
贪心算法需要选择物品以最大化背包中物品的总价值，同时不超过背包的总容量。
这种问题可以有多种变体，例如分数背包问题和完全背包问题。
2. 硬币找零问题：给定一组硬币的面值和数量，以及需要找零的金额。
贪心算法需要选择硬币以最小化找零的总数量。
这个问题可以通过从大到小排序硬币，并从最大面值的硬币开始选择，直到找零的金额达到所需的总金额。
3. 区间选点问题：给定一系列闭区间，每个闭区间都有一个起始点和结束点。
贪心算法需要选择尽量少的点，使得每个闭区间内至少有一个点被选中。
这个问题可以通过对结束点进行排序，并从左到右选择结束点，直到下一个要选择的结束点与上一个选择的结束点之间的距离大于当前选择的结束点与上一个选择的结束点之间的距离为止。
4. 区间覆盖问题：给定一系列闭区间，贪心算法需要选择尽量少的区间，使得所有区间都被覆盖。
这个问题可以通过对每个闭区间的左端点进行排序，并从左到右选择左端点，直到下一个要选择的左端点与上一个选择的左端点之间的距离大于当前选择的左端点与上一个选择的左端点之间的距离为止。
5. 排班问题：给定一组员工和他们的班次需求，以及一组工作日的日程安排。
贪心算法需要为员工分配班次，以最小化总工作时间并满足所有工作日的需求。
这个问题可以通过从可用的班次中选择最长的班次，并从左到右分配员工，直到所有员工都被分配到一个班次为止。
这些问题是贪心算法的经典示例，它们展示了贪心算法在解决优化问题中的广泛应用。
实验项目三 用蛮力法、动态规划法和贪心法求解背包问题
实验项目三 用蛮力法、动态规划法和贪心法求解0/1背包问题实验目的1、学会背包的数据结构的设计，针对不同的问题涉及到的对象的数据结构的设计也不同；2、对0-1背包问题的算法设计策略对比与分析。
实验内容：0/1背包问题是给定n 个重量为{w 1, w 2, … ,wn }、价值为{v 1, v 2, … ,vn }的物品和一个容量为C 的背包，求这些物品中的一个最有价值的子集，并且要能够装到背包中。
在0/1背包问题中，物品i 或者被装入背包，或者不被装入背包，设xi 表示物品i 装入背包的情况，则当xi =0时，表示物品i 没有被装入背包，xi =1时，表示物品i 被装入背包。
根据问题的要求，有如下约束条件和目标函数：于是，问题归结为寻找一个满足约束条件式1，并使目标函数式2达到最大的解向量X =(x 1, x 2, …, xn )。
背包的数据结构的设计：typedef struct object{int n;//物品的编号int w;//物品的重量int v;//物品的价值}wup;wup wp[N];//物品的数组，N 为物品的个数int c;//背包的总重量1、蛮力法蛮力法是一种简单直接的解决问题的方法，常常直接基于问题的描述和所涉及的概念定义。
蛮力法的关键是依次处理所有的元素。
用蛮力法解决0/1背包问题，需要考虑给定n 个物品集合的所有子集，找出所有可能的子集（总重量不超过背包容量的子集），计算每个子集的总价值，然后在他们中找到价值最大的子集。
所以蛮力法解0/1背包问题的关键是如何求n 个物品集合的所有子集，n 个物品的子集有2的n 次方个，用一个2的n 次方行n 列的数组保存生成的子集，以下是生成子集的算法：⎪⎩⎪⎨⎧≤≤∈≤∑=)1(}1,0{1n i x C x w i n i i i （式1）∑=ni i i x v 1max （式2）void force(int a[16][4])//蛮力法产生4个物品的子集{int i,j;int n=16;int m,t;for(i=0;i<16;i++){ t=i;for(j=3;j>=0;j--){m=t%2;a[i][j]=m;t=t/2;}}for(i=0;i<16;i++)//输出保存子集的二维数组{for(j=0;j<4;j++){printf("%d ",a[i][j]);}printf("\n");}｝以下要依次判断每个子集的可行性，找出可行解:void panduan(int a[][4],int cw[])////判断每个子集的可行性，如果可行则计算其价值存入数组cw,不可行则存入0{int i,j;int n=16;int sw,sv;for(i=0;i<16;i++){sw=0;sv=0;for(j=0;j<4;j++){sw=sw+wp[j].w*a[i][j];sv=sv+wp[j].v*a[i][j];}if(sw<=c)cw[i]=sv;elsecw[i]=0;}在可行解中找出最优解，即找出可行解中满足目标函数的最优解。
c语言算法--贪婪算法---01背包问题
c语言算法--贪婪算法---0/1背包问题在0 / 1背包问题中，需对容量为c 的背包进行装载。
从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。
对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高，即n ?i=1pi xi 取得最大值。
约束条件为n ?i =1wi xi≤c 和xi?[ 0 , 1 ] ( 1≤i≤n)。
在这个表达式中，需求出xt 的值。
xi = 1表示物品i 装入背包中，xi =0 表示物品i 不装入背包。
0 / 1背包问题是一个一般化的货箱装载问题，即每个货箱所获得的价值不同。
货箱装载问题转化为背包问题的形式为：船作为背包，货箱作为可装入背包的物品。
例1-8 在杂货店比赛中你获得了第一名，奖品是一车免费杂货。
店中有n 种不同的货物。
规则规定从每种货物中最多只能拿一件，车子的容量为c，物品i 需占用wi 的空间，价值为pi 。
你的目标是使车中装载的物品价值最大。
当然，所装货物不能超过车的容量，且同一种物品不得拿走多件。
这个问题可仿照0 / 1背包问题进行建模，其中车对应于背包，货物对应于物品。
0 / 1背包问题有好几种贪婪策略，每个贪婪策略都采用多步过程来完成背包的装入。
在每一步过程中利用贪婪准则选择一个物品装入背包。
一种贪婪准则为：从剩余的物品中，选出可以装入背包的价值最大的物品，利用这种规则，价值最大的物品首先被装入（假设有足够容量），然后是下一个价值最大的物品，如此继续下去。
这种策略不能保证得到最优解。
例如，考虑n=2, w=[100,10,10], p =[20,15,15], c = 1 0 5。
当利用价值贪婪准则时，获得的解为x= [ 1 , 0 , 0 ]，这种方案的总价值为2 0。
而最优解为[ 0 , 1 , 1 ]，其总价值为3 0。
另一种方案是重量贪婪准则是：从剩下的物品中选择可装入背包的重量最小的物品。
js贪心算法---背包问题
js贪⼼算法---背包问题 /** @param {Object} capacity 背包容量 6* @param {Object} weights 物品重量 [2,3,4]* @param {Object} values 物品价值 [3,4,5]*///贪⼼算法，只能算，可以分割的物品，如果不能分割物品，只能得到近似解，不分割物品，可以使⽤动态规划 //1、计算每件商品的（价格/质量），即单位质量的价值//2、将单位质量价值排序//3、逐个取出console.log(tanx(6,[2,3,4],[3,4,5]));function tanx(capacity,weights,values){var list = [];for(var i = 0,len = weights.length; i < len; i++){list.push({num:i+1, //第⼏件商品w:weights[i], //重量v:values[i],rate:values[i]/weights[i]});}list.sort(function(a,b){if(a.rate > b.rate){return -1;}else{return 1;}});var selects = [];var total = 0;for(var i = 0,len = list.length; i < len; i++){var item = list[i];if(item['w'] <= capacity){selects.push({num:item.num,rate:1 , //完整的商品记录为1v:item.v,w:item.w});total = total + item.v;capacity = capacity - item.w;}else if(capacity > 0){//选取不完整的商品var rate = capacity/item['w'];var v = item.v*rate;selects.push({num:item.num,rate: rate,v:item.v*rate,w:item.w*rate});total = total + v;break;}else{break;}}return {selects,total}}。
贪心算法之背包问题
贪⼼算法之背包问题贪⼼算法之背包问题1.与动态规划的区别通过研究解决经典的组合优化问题，来说明⼆者的差别。
即0-1背包问题与背包问题0-1背包问题：给定n中物品和⼀个背包。
物品i的重量为W i，其价值为V i，背包的容量为C。
应如何选择装⼊背包的物品，使得装⼊背包中物品的总价值最⼤？对于每种物品i只有俩种选择，即装⼊背包或不装⼊背包背包问题：与0-1背包问题类似，不同在于选择物品i装⼊背包时，可以选择物品i的⼀部分，⽽不⼀定要全部装⼊背包，1≤i≤n。
这2类问题都具有最优⼦结构性质，极为相似。
背包问题可以⽤贪⼼算法求最优解，0-1背包不能使⽤贪⼼求解。
2.贪⼼解决背包问题步骤贪⼼策略：每次选择单位重量价值最⾼的物品装⼊背包计算每种物品单位重量的价值V iW i，按单位重量的价值从⼤到⼩将n中物品排序。
以排序后的次序依次将物品装⼊背包。
直⾄全部物品都装⼊或者因背包容量不⾜不能装⼊为⽌如果背包尚有容量，将最后不能完全装⼊物品切割⼀部分装满背包算法结束3.代码实现/*** n 物品数* M 背包容量* v[] 物品价值数组* w[] 物品重量数组* x[] 保存最优解路径数组,为1则表⽰该物品完全装⼊，否则装⼊该物品的⼀部分**/void Knapsack(int n, float M, float v[], float w[], float x[]) {// 按照物品单位重量的价值递减排序Sort(n, v, w);int i;for (i = 1; i <= n; i++)x[i] = 0;float c = M;for (i = 1; i <= n; i++) {if (w[i] > c)break;x[i] = 1;c -= w[i];}if (i <= n)x[i] = c / w[i];}Processing math: 100%。
算法分析与设计实验三贪心算法
实验三贪心算法实验目的1. 掌握贪心法的基本思想方法；2. 了解适用于用贪心法求解的问题类型，并能设计相应贪心法算法；3. 掌握贪心算法复杂性分析方法分析问题复杂性。
预习与实验要求1. 预习实验指导书及教材的有关内容，掌握贪心法的基本思想；2. 严格按照实验内容进行实验，培养良好的算法设计和编程的习惯；3. 认真听讲，服从安排，独立思考并完成实验。
实验设备与器材硬件：PC机软件：C++或Java等编程环境实验原理有一类问题是要从所有的允许解中求出最优解，其策略之一是“贪心法”，即逐次实施“贪心选择”：在每个选择步骤上做出的选择都是当前状态下最优的。
贪心选择依赖于在此之前所做出的选择，但不依赖于后续步骤所需要的选择，即不依赖于后续待求解子问题。
显然，这种选择方法是局部最优的，但不是从问题求解的整体考虑进行选择，因此不能保证最后所得一定是最优解。
贪心法是求解问题的一种有效方法，所得到的结果如果不是最优的，通常也是近似最优的。
实验内容以下几个问题选做一项：1. 用贪心法实现带有期限作业排序的快速算法应用贪心设计策略来解决操作系统中单机、无资源约束且每个作业可在等量时间内完成的作业调度问题。
假定只能在一台机器上处理N个作业，每个作业均可在单位时间内完成；又假定每个作业i都有一个截止期限di>0（它是整数），当且仅当作业i在它的期限截止以前被完成时，则获得pi的效益。
这个问题的一个可行解是这N个作业的一个子集合J，J中的每个作业都能在各自的截止期限之前完成。
可行解的效益值是J中这些作业的效益之和，即Σp。
具有最大效益值的可行解就是最优解。
2. 实现K元归并树贪心算法两个分别包含n个和m个记录的已分类文件可以在O（n+m）时间内归并在一起而得到一个分类文件。
当要把两个以上的已分类文件归并在一起时，可以通过成对地重复归并已分类的文件来完成。
例如：假定X1,X2,X3,X4是要归并的文件，则可以首先把X1和X2归并成文件Y1，然后将Y1和X3归并成Y2，最后将Y2和X4归并，从而得到想要的分类文件；也可以先把X1和X2归并成Y1，然后将X3和X4归并成Y2，最后归并Y1和Y2而得到想要的分类文件。
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、贪心法截图：七、实验分析。
著名算法matlab编程 贪心算法 背包问题 递归算法 Hanoi塔问题 回溯算法 n皇后问题
10/22
在命令窗口输入：>> [n,s]=hanoi(3,1,2,3) n= 7 s= 1 2 1 3 1 2 1 1 1 3 1 2 2 1 3 2 2 3 1 3 3
1
1 2 3
2 3 3 3 1
2
3
1
2 1 2
1
1 2
2
3
3
1
2 3
1 2 3
11/22
5/22
A
B
C
1
2
n
6/22
问题分析： 把柱C作为目标柱子，设an为n块金片从其中一柱移 到另一柱的搬运次数，则把n块金片从A移到C，可 以先把前n-1片移到B，需搬an-1次；接着把第n片从 A称到C，再从B把剩下的n-1片搬到C，又需搬an-1 次。所以从A到n块金片称到柱C，共需次数为： 2an-1+1次。 显然，当n=1时，a1=1，所以Hanoi塔的移动次数相 当于一个带初值的递归关系：
有 旅 行 者 要 从 n 种 物 品 中 选 取 不 超 过 b公 斤 的 物 品 放 入 背 包 ， 要 求 总 价 值 最 大 。 设 第 i 种 物 品 的 重 量 为 a i， 价 值 为 c i，i 1, 2 , n )。 定 义 向 量 [ x 1 , x 2 , , x n ]， 当 选 第 i ( 种 物 品 往 背 包 放 时 取 x i 1， 否 则 取 x i 0。 于 是 所 有 选 取 的 物 品 的 总 价 值 为 ： c 1 x 1 c 2 x 2 c n x n， 总 的 重 量 为 ： a 1 x 1 a 2 x 2 a n x n。 问 题 可 描 述 为
用贪心法求解0-1背包问题
算法设计与分析期末论文题目用贪心法求解“0-1背包问题”专业计算机科学与技术班级09计算机一班学号0936021姓名黄帅日期2011年12月28日一、0-1背包问题的算法设计策略分析1.引言对于计算机科学来说，算法的概念是至关重要的，例如，在一个大型软件系统的开发中，设计出有效的算法将起决定性的作用。
算法是解决问题的一种方法或一个过程。
程序是算法用某种设计语言具体实现描。
计算机的普及极大的改变了人们的生活。
目前，各行业、各领域都广泛采用了计算机信息技术，并由此产生出开发各种应用软件的需求。
为了以最小的成本、最快的速度、最好的质量开发出适合各种应用需求的软件，必须遵循软件工程的原则。
设计一个高效的程序不仅需要编程小技巧，更需要合理的数据组织和清晰高效的素算法，这正是计算机科学领域数据结构与算法设计所研究的主要内容。
2. 算法复杂性分析的方法介绍算法复杂性是算法运行所需要的计算机资源的量，需要时间资源的量称为时间复杂性，需要的空间资源的量称为空间复杂性。
这个量应该只依赖于算法要解的问题的规模、算法的输入和算法本身的函数。
如果分别用N 、I 和A 表示算法要解问题的规模、算法的输入和算法本身，而且用C 表示复杂性，那么，应该有C=F(N,I,A)。
一般把时间复杂性和空间复杂性分开，并分别用T 和S 来表示，则有： T=T(N,I)和S=S(N,I) 。
（通常，让A 隐含在复杂性函数名当中最坏情况下的时间复杂性：最好情况下的时间复杂性：平均情况下的时间复杂性：其中DN 是规模为N 的合法输入的集合；I*是DN 中使T(N, I*)达到Tmax(N)的合法输入； 是中使T(N, )达到Tmin(N)的合法输入；而P(I)是在算法的应用中出现输入I 的概率。
算法复杂性在渐近意义下的阶：渐近意义下的记号：O 、Ω、θ、o 设f(N)和g(N)是定义在正数集上的正函数。
O 的定义：如果存在正的常数C 和自然数N0，使得当N ≥N0时有f(N)≤Cg(N)，则称函数f(N)当N 充分大时上有界，且g(N)是它的一个上界，记为f(N)=O(g(N))。
使用JAVA实现算法——贪心算法解决背包问题
使⽤JAVA实现算法——贪⼼算法解决背包问题解释等全部在代码中，⾃⼰跑了下，是没问题的package BasePart;import java.io.BufferedReader;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStreamReader;/*** 使⽤贪⼼算法解决背包问题* 背包问题：* 旅⾏者有背包容量m公⽄* 现在有重量W1,W2,W3,W4....Wn* 对应的价值V1,V2,V3,V4....Vn* 运⾏重复携带，欲求得最⼤价值* 贪⼼算法：求得最好的选择，但是贪⼼算法不是对于所有的问题都得到整体最优解* 贪⼼算法基本思路：* 1.建⽴数学模型来描述问题* 2.把求解问题分成若⼲个⼦问题* 3.对于每⼀个⾃问题求得局部最优解* 4.把⼦问题的解局部最优解合成原来解问题的⼀个解* 贪⼼算法的实现过程：* 从⼀个初始解出发* while-do朝总⽬标前进* 求出可⾏解的⼀个解元素* 由所有解元素组成合成问题的⼀个可⾏解*/public class Greedy {/*解决背包问题*需要背包容量*背包价值*背包剩余容量*解向量集合*/private double total_weight;private double total_value;private double rest_weight;//储存排序数组private Good[] arrayValue;private Good[] arrayWeight;private Good[] arrayC_P;private int goodsNum;private Good[] goods;private double real_weight;public Greedy() {}public Greedy(int goodsNum,double total_weight) {this.goodsNum=goodsNum;this.total_weight=total_weight;}public void init(String filename) throws IOException {/** 1.初始化程序* 2.从TXT⽂件中得到商品重量和其价值数组* 3.初始化序列数组arrayValue/Weight/C_P*/goods=new Good[goodsNum];BufferedReader data=new BufferedReader(new InputStreamReader(new FileInputStream(filename)));String buff;String[] strs;//循环赋值for(int i=0;i<4;i++){buff=data.readLine();strs=buff.split(" ");//根据位次goods[i]=new Good();//对象数组不仅仅需要初始化数组，对于数组内的每⼀个对象也需要初始化goods[i].setName(strs[0]);goods[i].setValue(Double.parseDouble(strs[1]));goods[i].setWeight(Double.parseDouble(strs[2]));goods[i].figureC_P();}//关闭输⼊流//成员变量初始化arrayValue=new Good[goodsNum];arrayWeight=new Good[goodsNum];arrayC_P=new Good[goodsNum];//初始化数组/** 价值由⼤到⼩数组*/arrayValue=arrayCopy(goods, arrayValue);//按照价值对arrayValue数组进⾏重新排列，使⽤冒泡排序法for(int i=0;i<goodsNum-1;i++){//从⼤到⼩排列for(int j=i+1;j<goodsNum;j++){if(arrayValue[i].getValue()<arrayValue[j].getValue()){Good temp=arrayValue[i];arrayValue[i]=arrayValue[j];arrayValue[j]=temp;}}}/**质量由⼩到⼤数组*/arrayWeight=arrayCopy(goods, arrayWeight);//按照价值对arrayWeight数组进⾏重新排列，使⽤冒泡排序法for(int i=0;i<goodsNum-1;i++){//从⼩到⼤排列for(int j=i+1;j<goodsNum;j++){if(arrayWeight[i].getWeight()>arrayWeight[j].getWeight()){Good temp=arrayWeight[i];arrayWeight[i]=arrayWeight[j];arrayWeight[j]=temp;}}}/** 性价⽐由⼤到⼩排列*/arrayC_P=arrayCopy(goods, arrayC_P);//按照价值对arrayC_P数组进⾏重新排列，使⽤冒泡排序法for(int i=0;i<goodsNum-1;i++){//从⼤到⼩排列for(int j=i+1;j<goodsNum;j++){if(arrayC_P[i].getC_P()<arrayC_P[j].getC_P()){Good temp=arrayC_P[i];arrayC_P[i]=arrayC_P[j];arrayC_P[j]=temp;}}}}//⽤于数组拷贝public Good[] arrayCopy(Good[] goods,Good[] arr2){arr2=goods.clone();return arr2;}private void show(Good[] goodsarr) {for(Good good:goodsarr){System.out.println(good.getName()+"\t"+good.getValue()+"\t"+good.getWeight()+"\t"+good.getC_P()+"\t"+good.getNum()); }}/*三种策略：度量准则* 依次选取价值最⼤填充* 依次选取重量最轻填充* 依次选取⽐价最⼤填充** ⽅法设计：* 按照度量准则* 传递⼀个按照选择优先级排列的对象数组* 迭代计算剩余容量* 返回设计⽅案*/public void strategy(Good[] goodsArray){rest_weight=total_weight;for(Good good:goodsArray){int selectNum=(int)Math.floor(rest_weight/good.getWeight());rest_weight=rest_weight-selectNum*good.getWeight();good.setNum(selectNum);if(rest_weight<arrayWeight[0].getWeight()){continue;}}}public void calculate(Good[] goodsArray,String target){total_value=0;real_weight=0;//处理结果System.out.println("在以"+target+"为准则的情况下");for(Good good:goodsArray){System.out.println(good.getName()+"\t\t数量："+good.getNum());total_value+=good.getValue()*good.getNum();real_weight+=good.getWeight()*good.getNum();}System.out.println("总价值是:\t"+total_value+"\t总重量是:\t"+real_weight); }public void solve() {/** 业务逻辑* 将优先级数组*/strategy(arrayValue);calculate(arrayValue,"价值");strategy(arrayWeight);calculate(arrayWeight,"重量");strategy(arrayC_P);calculate(arrayC_P,"⽐值");}public static void main(String[] args) throws IOException {Greedy greedy=new Greedy(4,50);greedy.init("goods.txt");greedy.solve();}}Txt⽂本为：ad钙奶 12 5ab胶带 6 1电脑 4000 30⾳响 500 15说明：第⼀列：名称第⼆列：价格第三列：重量程序运⾏结果为：待改善。
背包问题的贪心算法
Wi Xi
16.5 20 20 20
Vi X i
24.25 28.2 31 31.5
先检验这四个为可行解*,即满足约束条件(4.2.2),(4.2.3).再比 较目标函数值,∑vixi .知④组解效益值最大.该组解是背包问题的最 优解。(见定理4.2）
6
例4.4 n＝3,c＝20, (V1,V2,V3) (25, 24,15) (W1,W2,W3) (18,15,10)
7
，且物品2的24/15 = v2/w2 较物品3的15/10＝ v3/w3效益值高。按 此选择策略,得②即(1, 2/15, 0),∑vixi=28.2 .此解是一个次优解。 显然，按物品效益值的非增次序装包不能得最优解。
原因：背包可用容量消耗过快。
（2）以容量作为量度。即按物品重量的非降次序将物
—选取最优的量度标准实为用贪心方法求解问题的核心.
16
4.3 贪心算法的基本要素
1.贪心选择性质
所谓贪心选择性质是指所求问题的整体最优解可以 通过一系列局部最优的选择，即贪心选择来达到。这 是贪心算法可行的第一个基本要素，也是贪心算法与 动态规划算法的主要区别。
动态规划算法通常以自底向上的方式解各子问 题，而贪心算法则通常以自顶向下的方式进行，以迭 代的方式作出相继的贪心选择，每作一次贪心选择就 将所求问题简化为规模更小的子问题。
品装包。如例4.4中的解③（让背包尽可能慢被消耗）
排序 : (w3,w2,w1)= (10,15,18)
(V3,V2,V1) (15, 24, 25)
V3=15,x3=1,w3=10,背包剩余C－10＝10;物品2有次大重量(w2＝15), 但包装不下。使用x2＝2/3，刚好装满背包且物品2装入2/3与物品1 装入5/9的容量均为10个单位。但前者的效益值24×2/3=16 >后者
背包问题的贪心算法
实际上，动态规划算法的确可以有效地解0-1背包问题。
4
4.2 背包问题
已知有n种物品和一个可容纳c重量的背包，每种物品i的
重量为wi。假定物品i的一部分放入背包会得到vixi的效益。其
中0≤xi≤1,vi>0 . 采用怎样的装包方法才会使装入背包物品的总
效益最大呢？即求解 n
max Vi X i
对于一个具体问题，要确定它是否具有贪心选择 性质，必须证明每一步所作的贪心选择最终导致问题 的整体最优解。
17
4.3 贪心算法的基本要素
2.最优子结构性质
当一个问题的最优解包含其子问题的最优解时，称 此问题具有最优子结构性质。问题的最优子结构性质 是该问题可用动态规划算法或贪心算法求解的关键特 征。
的量，使得所用的总容量仍是c，这导致一个新的解
Z=(z1,…,zn)，其中zi＝xi ,1≤i≤k,且 。因此，对于Z有
wi yi zi wk zk yk
k jn
vi zi vi yi zk yk wkvk / wk ( yi zi )wivi / wi
1in
1in
18
4.3 贪心算法的基本要素
3.贪心算法与动态规划算法的差异
贪心算法和动态规划算法都要求问题具有最优子结构 性质，这是2类算法的一个共同点。但是，对于具有最 优子结构的问题应该选用贪心算法还是动态规划算法 求解?是否能用动态规划算法求解的问题也能用贪心算 法求解?下面研究2个经典的组合优化问题，并以此说 明贪心算法与动态规划算法的主要差别。
贪心算法实现背包问题算法设计与分析实验报告
算法设计与分析实验报告实验名称贪心算法实现背包问题评分实验日期年月日指导教师姓名专业班级学号一.实验要求1. 优化问题有n个输入，而它的解就由这n个输入满足某些事先给定的约束条件的某个子集组成，而把满足约束条件的子集称为该问题的可行解。
可行解一般来说是不唯一的。
那些使目标函数取极值(极大或极小)的可行解，称为最优解。
2.贪心法求优化问题算法思想：在贪心算法中采用逐步构造最优解的方法。
在每个阶段，都作出一个看上去最优的决策（在一定的标准下）。
决策一旦作出，就不可再更改。
作出贪心决策的依据称为贪心准则（greedy criterion）。
3.一般方法1）根据题意，选取一种量度标准。
2）按这种量度标准对这n个输入排序3）依次选择输入量加入部分解中。
如果当前这个输入量的加入，不满足约束条件，则不把此输入加到这部分解中。
procedure GREEDY(A，n) /*贪心法一般控制流程*///A(1：n)包含n个输入//solutions←φ //将解向量solution初始化为空／for i←1 to n dox←SELECT(A)if FEASIBLE(solution，x)then solutions←UNION(solution，x)endifrepeatreturn(solution)end GREEDY4. 实现典型的贪心算法的编程与上机实验，验证算法的时间复杂性函数。
二.实验内容1. 编程实现背包问题贪心算法。
通过具体算法理解如何通过局部最优实现全局最优，并验证算法的时间复杂性。
2.输入5个的图的邻接矩阵，程序加入统计prim算法访问图的节点数和边数的语句。
3.将统计数与复杂性函数所计算比较次数比较，用表格列出比较结果，给出文字分析。
三.程序算法1.背包问题的贪心算法procedure KNAPSACK(P，W，M，X，n)//P(1：n)和W(1；n)分别含有按P(i)/W(i)≥P(i+1)/W(i+1)排序的n件物品的效益值和重量。
列举用贪心算法求解的经典问题
列举用贪心算法求解的经典问题
1. 零钱兑换问题：给定一些面值不同的硬币和一个金额，要求用最少的硬币凑出这个金额。
2. 最小生成树问题：给定一个无向带权图，要求用最小的权值构建一棵生成树。
3. 背包问题：给定一些物品和一个背包，每个物品有对应的价值和重量，要求在背包容量限制下，选取物品使得总价值最大。
4. 活动安排问题：有若干个活动需要分配一段时间，每个活动有对应的开始时间和结束时间，要求选取尽可能多的活动，使得任两个安排的活动时间不重叠。
5. 单源最短路径问题：给定一个有向带权图和一个起始节点，要求求出从起始节点到其他所有节点的最短路径。
6. 任务调度问题：有若干个需要完成的任务和多个可执行任务的处理器，要求将任务分配给处理器，使得执行总时间最小。
7. 区间覆盖问题：给定一些区间，要求用尽可能少的区间覆盖整个线段。
8. 哈夫曼编码问题：给定一些字符及其对应的出现概率，要求用最短的编码方式表示这些字符。
第8章贪心算法-分数背包问题
贪心算法:
算法GREEDY_KANPSACK
输入：表示背包容量的实数C,物品数n,表示n个物品的体积和价值的实数数组s[1..n]和v[1..n]。
输出：装入背包物品的最大总价值maxv和相应的最优解x[1..n]。
for i=1 to n
y[i]=v[i]/s[i]//求n个物品的单位体积价值y[1..n]。
end for
//对y[1..n]按降序地址排序，排序结果返回到数组d[1..n]//中,使得
y[d[1]]>=y[d[2]]>=…>=y[d[n]]。
d=sort(y, n)
for i=1 to nx[i]=0//对x[1..n]初始化。
i=1;maxv=0;rc=C//以下rc表示当前背包的剩余容量。
while rc>0 and i<=n
j=d[i]// u
j为当前考虑选择的物品
if s[j]<=rc then
x[j]=1;rc=rc-s[j]//物品u
j全部装入背包。
else
x[j]=rc/s[j]//选择物品u
j的一部分将背包填满。
rc=0
end if
maxv=maxv+v[j]*x[j]
i=i+1
end while
return maxv, x[1..n]
end GREEDY_KNAPSACK
●算法的时间复杂性：Θ(nlogn)
间)
思考：0/1背包问题可否用贪心法解？(主要为排序的时。
基于朴素贪心算法的背包问题解决方案
基于朴素贪心算法的背包问题解决方案背包问题是一类经典的组合优化问题，它的一般形式描述为：有一个固定大小的背包，和一些物品，每个物品都有自己的价值和大小，需要选出一些物品装入背包中，使得装进去的物品价值最大化，同时又不能超出背包容量的限制。
这个问题在实际生活中有很多应用，比如在货物的装载和运输、在零售商的库存管理、在网页推荐系统等等。
解决背包问题的方法有很多，其中比较经典的是基于动态规划的解法，但是这种解法需要使用大量的存储空间，如果物品数量很大的话，计算复杂度也会很高。
因此本文将介绍一种基于朴素贪心算法的背包问题解决方案。
一、背包问题的数学模型在介绍具体的解决方案之前，我们需要先来看一下背包问题的数学模型。
假设我们有n个物品，第i个物品的重量为wi，价值为vi，背包的容量为W。
那么背包问题可以用下面的数学模型来描述：$$\begin{aligned}&\max\sum_{i=1}^{n}v_ix_i\\&s.t.\sum_{i=1}^ {n}w_ix_i\leq W\\&x_i\in \{0,1\}\end{aligned}$$其中，$x_i$表示第$i$个物品是否被选中，$v_i$和$w_i$分别表示第$i$个物品的价值和重量。
第一个约束条件表示所有选中的物品的总重量不能超过背包的容量$W$，第二个约束条件表示每个物品最多只能选一次。
二、基于朴素贪心算法的解法朴素贪心算法的思路很简单：每次选择可行的物品中价值最大的那一个，直到不能再选为止。
对于背包问题来说，我们可以按照物品的单位价值（即价值与重量比值）从大到小排序，然后依次选择可行的物品加入背包中。
具体步骤如下：1. 计算每个物品的单位价值，按照单位价值从大到小排序。
2. 依次加入可行的物品，直到不能再加入为止。
3. 最后得到的物品组合就是背包问题的最优解。
该算法的时间复杂度为$O(nlogn)$，其中$n$为物品的数量。
贪心算法与背包问题的求解策略
贪心算法与背包问题的求解策略贪心算法（Greedy Algorithm）是一种常用的算法策略，用于求解最优化问题。
背包问题（Knapsack Problem）则是一个经典的组合优化问题，涉及在限制条件下如何选择物品以最大化价值。
本文将探讨贪心算法在解决背包问题时的应用与求解策略。
一、背包问题简介背包问题是一个常见的动态规划问题，其基本形式为：有一个背包，容量为C（常为非负整数），有n个物品，每个物品的重量为w[i]，价值为v[i]。
现在需要从这些物品中选择一部分装入背包，使得在满足背包容量的限制下，所装入物品的总价值最大化。
二、贪心算法的基本思想贪心算法的基本思想是，每一步都选择当前情况下的最优解，希望通过每一步的最优解最终达到全局最优解。
然而，贪心算法并不是适用于所有问题的通用解决方法，它适用于一些特定的问题，如背包问题。
三、贪心算法在背包问题中的应用在背包问题中，常见的贪心策略有两种：按价值密度排序和按重量排序。
下面将分别介绍这两种贪心策略的具体应用。
1. 按价值密度排序按价值密度排序是指将物品按照单位重量的价值从大到小进行排序。
具体操作步骤如下：（1）计算每个物品的价值密度，即v[i]/w[i]。
（2）按照价值密度从大到小的顺序对物品进行排序。
（3）从价值密度最高的物品开始，依次将物品放入背包，直至背包容量达到上限或无物品可放。
2. 按重量排序按重量排序是指将物品按照重量从小到大进行排序。
具体操作步骤如下：（1）按照物品的重量从小到大进行排序。
（2）从重量最小的物品开始，依次将物品放入背包，直至背包容量达到上限或无物品可放。
四、贪心算法的优缺点贪心算法相比其他算法具有简单、高效的特点。
然而，贪心算法并不是万能的，它在某些情况下可能无法得到最优解。
例如，在背包问题中，贪心算法按照价值密度排序的策略并不能保证一定能得到最优解，因为可能存在某些物品的价值密度很高，但重量也很大，无法放入背包。
五、贪心算法的应用场景贪心算法常被应用于一些特定的问题领域，如最小生成树、调度问题、图着色等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
int[] w;
int[] v;
Scanner scan=new Scanner(System.in);
System.out.print("输入背包的容量:");
c=scan.nextInt();
System.out.print("输入物品的数量:");
N=scan.nextInt();
System.out.print("分别输入物品的价值:");
v=new int[N];
for(int i=0;i<N;i++)
{
v[i]=scan.nextInt();
}
System.out.print("分别输入物品的重量:");
w=new int[N];
for(int i=0;i<N;i++)
int c;
int[] w;
int[] v;
Scanner scan=new Scanner(System.in);
System.out.print("输入背包的容量:");
c=scan.nextInt();
System.out.print("输入物品的数量:");
N=scan.nextInt();
}
}
for(int j = 0;j<N;j++)
totalx=totalx+n[j]*v[j];
ShowResult s = new ShowResult(v,w,N,n,totalx);
}
2.3、编程实现题目要求；
2.4、调试程序；
2.5、实验数据及实验结果；
输入数据：背包容量为50公斤。物品1重10公斤，价值60元；物品2重20公斤，价值100元；物品3重30公斤，价值120元。
for(int i= 0;i<N;i++)
for(int j=i+1;j<N;j++)
{
if(x[i] < x[j]){来自temp2 = x[j];
x[j] = x[i];
x[i] =temp2;
temp1 = v[j];
v[j] = v[i];
v[i] = temp1;
temp1 = w[j];
w[j] = w[i];
{
w[i]=scan.nextInt();
}
System.out.println();
int [] wCopy = new int [N];
int [] vCopy = new int [N];
float temp2;
int temp1;
float totalx=0;
float [] x = new float [N];//价值和重量的比值
}
}
for(int j = 0;j<N;j++)
totalx=totalx+n[j]*v[j];
ShowResult s = new ShowResult(v,w,N,n,totalx);
System.out.print("分别输入物品的价值:");
v=new int[N];
for(int i=0;i<N;i++)
{
v[i]=scan.nextInt();
}
System.out.print("分别输入物品的重量:");
w=new int[N];
for(int i=0;i<N;i++)
float [] n =new float[N];//记录个数
float [] nCopy = new float[N];
for(int i=0;i<N;i++)
{
wCopy [i] = w[i];
vCopy [i] = v[i];
}
for (int i=0;i<N;i++)
x[i] = (float) ((v[i]*1.0)/w[i]);
w[i] = temp1;
}
}//效益重量比值排序
Backpack b = new Backpack(c,w,v,n);
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
{
if(wCopy[i]==w[j] && vCopy[i]==v[j])
{
nCopy[i] = b.n[i];
输出结果：
2.6、算法时间复杂度
O(nlogn)
三、总结
通过本次实验，加深了我对背包问题及贪心算法的理解。
附录：源代码
import java.util.Scanner;
import java.text.DecimalFormat;
public class greedbag
{
greedbag()
{
int N;
{
w[i]=scan.nextInt();
}
System.out.println();
int [] wCopy = new int [N];
int [] vCopy = new int [N];
float temp2;
int temp1;
float totalx=0;
float [] x = new float [N];//价值和重量的比值
float [] n =new float[N];//记录个数
float [] nCopy = new float[N];
for(int i=0;i<N;i++)
{
wCopy [i] = w[i];
vCopy [i] = v[i];
}
for (int i=0;i<N;i++)
x[i] = (float) ((v[i]*1.0)/w[i]);
《算法分析与设计》
课程实验
专业年级：信息与计算科学
学生学号：
学生姓名：
实验题目：用贪婪法求解背包问题
指导老师：
实验时间：20xx年xx月x日
一、实验内容
用贪婪法求解背包问题
要求：用非递归实现
二、实验步骤
2.1、理解算法思想和问题要求；
2.2、写出每个操作的算法
非递归算法：
greedbag()
{
int N;
w[i] = temp1;
}
}//效益重量比值排序
Backpack b = new Backpack(c,w,v,n);
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
{
if(wCopy[i]==w[j] && vCopy[i]==v[j])
{
nCopy[i] = b.n[i];
for(int i= 0;i<N;i++)
for(int j=i+1;j<N;j++)
{
if(x[i] < x[j])
{
temp2 = x[j];
x[j] = x[i];
x[i] =temp2;
temp1 = v[j];
v[j] = v[i];
v[i] = temp1;
temp1 = w[j];
w[j] = w[i];