贪心算法实现背包问题算法设计与分析实验报告
贪心算法求连续背包问题
实验项目名称:贪心算法求连续背包问题一、实验目的:明确连续背包问题的概念;利用贪心算法解决连连续续背包问题;并通过本例熟悉贪心算法在程序设计中的应用方法。
二、实验原理: 贪心算法原理:在贪婪算法(greedy method )中采用逐步构造最优解的方法。
在每个阶段,都作出一个看上去最优的决策(在一定的标准下)。
决策一旦作出,就不可再更改。
作出贪婪决策的依据称为贪婪准则(greedy criterion )。
三、实验内容与步骤:贪心算法求连续背包问题问题描述:已知n 个物体和1个背包,其中物体i 有重量w i 和价值v i ,背包承重量为W 。
求一装载方案,要求在不超过背包负重的前提下,背包中装入的物品价值最大。
很明显,如果1ni i w W =≤∑,则最优解就是装入全部物体,因此下面假设1n i i w W =>∑。
注:连续背包问题中的物体可以任意分割,即部分装入背包。
分析:连续背包问题可形式化为如下模型:{}11max ..[0,1],1,,ni ii ni ii i x v x w W s t x i n ==⎧≤⎪⎨∈∈⎪⎩∑∑对于连续背包问题,可用贪心技术求得最优解。
贪心策略是单位重量价值高者优先。
例如:所给物体的重量和价值如下,则,程序可以得到如下结果:最大价值为163.0;所选各物体的数量为:1.0 1.0 1.0 0.8参考程序段如下//连续背包问题的贪心算法,最大单位重量价值优先//输入:各物体重量w 、价值v 和背包重量W ,已按v/w 降序排列#include<stdio.h>int knapsack(int n1,float w1[],float v1[],float W1){ int i; float weight; float x[10],s=0; for(i=1;i<=n1;i++) x[i]=0; weight=0; i=1;while(weight<W1) {if(weight+w1[i]<W1){x[i]=1;weight=weight+w1[i];}else{x[i]=(W1-weight)/w1[i];weight=W1;}i++;}for(i=1;i<=n1;i++) s=s+x[i]*v1[i];printf("背包所能容纳商品的最大价值为:%f\n",s);printf("所选择的商品的一个序列为:\n");for(i=1;i<=n1;i++)printf("%8.3f",x[i]);}void main(){int n,i,j;float w[10],v[10],W;clrscr();printf("输入商品数量n 和背包容量W:\n");scanf("%d,%f",&n,&W);printf("输入每件商品的重量,价值:\n");for(i=1;i<=n;i++)scanf("%f,%f",&w[i],&v[i]);knapsack(n,w,v,W);printf("\n");system("pause");}。
01背包贪心算法
0—1背包问题一、实验目的学习掌贪心算法法思想。
二、实验内容用分支限定法求解0—1背包问题,并输出问题的最优解。
0—1背包问题描述如下:给定n种物品和一背包。
物品i的重量是Wi,其价值为Vi,背包的容量是c,问应如何选择装入背包中的物品,使得装入背包中物品的总价值最大。
三、实验条件Jdk1.5以上四、需求分析对于给定n种物品和一背包。
在容量最大值固定的情况下,要求装入的物品价值最大化。
五、基本思想:总是对当前的问题作最好的选择,也就是局部寻优。
最后得到整体最优。
总是选择单位价值最高的物品六、详细设计package sunfa;/**** @author Administrator*/import java.util.*;public class Greedy_Algorithm {static Element dd[];static int CurrentV ;static int CurrentC;static StringBuffer stb= new StringBuffer();public static int knapasck(int c, int[] w, int[] v, int[] x) {int n = v.length;Element d [] = new Element[n];for(int i = 0 ;i< n; i++){d[i]=new Element(w[i],v[i],i+1);}//按单位重量价值升序排序Arrays.sort(d);dd =d;/*for(int i = 0; i<d.length ;i++){System.out.println("重量" +d[i].ww+ "单位价值"+d[i].wv);}*/int i = 0;int MaxV2 = 0;for(i=0;i<n;i++)x[i] = 0;for(i=0;i<n;i++){if(d[i].ww>c)break;else{x[i] = d[i].tag; //x【】中存的是原元素的序号MaxV2 = MaxV2+d[i].value;c = c -d[i].ww;CurrentC =c ;stb.append("选择第" + d[i].tag + "个当前价值:"+MaxV2+ "剩余容量:"+c+"\n");}}return MaxV2;}}class Element implements Comparable{int ww; //物品重量int value; //物品价值double wv;//物品单位重量的价值int tag;//物品的标志是第一个物品public Element(int w ,int vv ,int tag){this.tag = tag;this.ww = w;this.value = vv;wv = (double)vv/w;}//对象比较的方法public int compareTo(Object x){Element temp = (Element)x;double rate = (double)ww/value;double temprate = (double)temp.ww/temp.value;if(rate<temprate)return -1;if(rate==temprate)return 0;elsereturn 1;}}运行结果(用列一)用列二上述结果显示:贪心算法不是总是最优的.动态规划与贪心算法比较;动态规划法又和贪婪算法有些一样,在动态规划中,可将一个问题的解决方案视为一系列决策的结果。
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)不是,与假设矛盾。
贪心法解决背包问题
算法分析实验报告贪心法解决背包问题学生姓名:专业:班级:学号:指导教师:2017年6月12日目录一、实验题目 (2)二、实验目的 (2)三、实验要求 (2)四、实现过程 (3)1、实验设计: (3)2、调试分析 (5)3、运行结果: (6)4、实验总结: (6)五、参考文献 (6)一、实验题目贪心法解决背包问题二、实验目的1)以背包问题为例,掌握贪心法的基本设计策略。
2)熟练掌握各种贪心策略情况下的背包问题的算法并实现;其中:量度标准分别取:效益增量v、物品重量w、v/ w比值;3) 分析实验结果来验证理解贪心法中目标函数设计的重要性。
三、实验要求1.[问题描述]:给定n种物品和一个背包。
物品i的重量是Wi,其价值为Vi,背包的容量为C。
应如何选择装入背包的物品,使得装入背包中物品的总价值最大? 与0-1背包问题类似,所不同的是在选择物品i装入背包时,可以选择物品i的一部分,而不一定要全部装入背包,但不可以重复装入。
2.[算法]:贪心法的基本思路:从问题的某一个初始解出发逐步逼近给定的目标,以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时,算法停止。
该算法存在问题:1)不能保证求得的最后解是最佳的;2)不能用来求最大或最小解问题;3)只能求满足某些约束条件的可行解的范围。
四、实现过程1、实验设计:1.用贪心法求解背包问题的关键是如何选定贪心策略,使得按照一定的顺序选择每个物品,并尽可能的装入背包,直至背包装满。
至少有三种看似合理的贪心策略:1)按物品价值v降序装包,因为这可以尽可能快的增加背包的总价值。
但是,虽然每一步选择获得了背包价值的极大增长,但背包容量却可能消耗太快,使得装入背包得物品个数减少,从而不能保证目标函数达到最大。
2)按物品重量w升序装包,因为这可以装入尽可能多的物品,从而增加背包总价值。
但是,虽然每一步选择使背包得容量消耗得慢了,但背包价值却没能保证迅速增长,从而不能保证目标函数达到最大。
01背包问题实验报告
算法设计与分析实验报告书实验名称:0/1背包问题学号:姓名:实验时间:2015年 6 月 1 日一实验目的和要求(1)深刻掌握贪心法、动态规划法、回溯法的设计思想并能熟练运用(2)理解这样一个观点:同样的问题可以用不同的方法来解决,一个好的算法是反复努力和重新修正的结果。
二实验内容(1)分别用蛮力法贪心法、动态规划法、回溯法设计0/1背包问题的算法。
(2)分析算法随n和C变化的时间性能,随机产生参数n和C,收集算法执行的时间(3)讨论n和C变化时,动态规划法和回溯法的时间性能。
(4)讨论几种算法在该问题求解上的特点。
三实验环境VC++6.0四设计思想及实验步骤蛮力法的设计思想和步骤将所有排列下的背包的重量和价值都计算出来,选择重量不大于背包的总重量下的最大价值。
贪心法的设计思想和步骤首先计算每种物品单位重量的价值vi/wi;按单位价值对物品进行升序排列。
然后,依贪心选择策略,将尽可能多的单位重量价值最高的物品装入背包,直到背包装满为止。
动态规划法的设计思想和步骤令V(i, j)表示在前i个物品中能够装入容量为j的背包中的物品的最大价值,则可以得到如下动态函数:V(i, j)=0 (i=0或j=0)V( i, j) = V(i-1, j) j<w[i]V( i, j) = max{V(i-1, j), V(I, j-1)+v[i]} j>=w[j]按照下述方法来划分段:第一段只装入前1个物品,确定在各种情况下的背包能够得到的最大价值;第二阶段,只装入2个物品,确定在各种情况下的背包能够得到的最大价值;以此类推,直到第n个阶段。
最后V(n, C)便是容量为C的背包中装入n个物品时获取到的最大价值。
回溯法的设计思想和步骤为了避免生成那些不可能产生最佳解的问题状态,要不断的利用越约束条件来剪掉那些实际上不可能产生所需解的节点,以减少问题额计算量。
对于n种可选物品的0/1背包问题,其解空间长度由长度为n的0-1向量组成,可用子集数表示。
贪婪法求解背包问题
贪婪法求解背包问题-CAL-FENGHAI.-(YICAI)-Company One1实验二贪婪法一、实验目的1)理解和掌握贪婪算法的基本思想;2)使用贪婪算法求解背包问题以及最小花费生成树问题。
二、方法原理贪心算法就是做出一系列选择,使原问题达到最优解。
在每一个决策点,都是做出当前看来的最优选择。
三、实验设备PC机一台,C语言、PASCAL语言、Matlab任选四、方法原理贪心算法就是做出一系列选择,使原问题达到最优解。
在每一个决策点,都是做出当前看来的最优选择。
五、实验内容1)利用贪婪法求如下背包问题的最优解:n=5,M=100,价值P={20,30,66,40,60 },重量为w={10,20,30,40,50}。
六、实验要求1)认真分析题目的条件和要求,复习相关的理论知识,选择适当的解决方案和算法;2)编写上机实验程序,作好上机前的准备工作;3)上机调试程序,并试算各种方案,记录计算的结果(包括必要的中间结果);4)分析和解释计算结果;5)按照要求书写实验报告;源代码:#include<stdio.h>#include<stdlib.h>#include<iostream>using namespace std;#define n 5#define M 100typedef struct {int s;float p;//价值float w;float t;//价值重量比float x;}OBJECT;OBJECT obj[n];void swap(float &x, float &y) {float t;t = x;x = y;y = t;}float divide_and_conquer(OBJECT obj[], int low, int high) { int k, i = low;float z = obj[low].t;for (k = low + 1; k <= high; k++) {if (obj[k].t>z) {i += 1;if (i != k)swap(obj[i], obj[k]);}}swap(obj[low], obj[i]);return i;}void quick_sort(OBJECT obj[], int low, int high) {int k;if (low < high) {k = divide_and_conquer(obj, low, high);quick_sort(obj, low, k - 1);quick_sort(obj, k + 1, high);}}void sort_recover(OBJECT obj[]) {int i, j,temp;for (i = 0; i < n-1; i++) {for (j = 0; j < n - 1 - i; j++) {if (obj[j].s > obj[j + 1].s)swap(obj[j], obj[j + 1]);}}}float knapsack_greedy(OBJECT obj[]) {int i;float m,r=0;for(i=0;i<n;i++){obj[i].t=obj[i].p/obj[i].w;obj[i].x = 0;}quick_sort(obj,0,4);m = M;printf(" 物体价值重量价值重量比结果\n");printf("=========================================\n");for (i = 0; i < n; i++) {if (obj[i].w <= m) {obj[i].x = 1;m -= obj[i].w;r += obj[i].p;}else {obj[i].x = m / obj[i].w;r += obj[i].x * obj[i].p;break;}}return r;}void main() {int i;float r;//float x[] = { 0 };float s[] = { 1,2,3,4,5 };float p[]={ 20,30,66,40,60 };float w[]={ 10,20,30,40,50 };for (i = 0; i < n; i++) {obj[i].s = s[i];obj[i].p = p[i];obj[i].w = w[i];}r = knapsack_greedy(obj);sort_recover(obj);for (i = 0; i < n; i++) {printf(" %d %2.0f %2.0f %2.1f %1.1f\n", obj[i].s, obj[i].p, obj[i].w, obj[i].t, obj[i].x);}printf("\n最大价值为:%f\n",r );printf("背包问题的解向量:X={");for (i = 0; i < n; i++) {printf("%1.1f",obj[i].x);if(i<4)printf(",");}printf("}");system("pause");}结果:。
matlab中贪婪算法求解背包问题的研究与应用
matlab中贪婪算法求解背包问题的研究与应用背包问题是一种特殊的最优化问题,常见于组合优化中。
在一般情况下,它要求从多种物品中挑选出某种数量的物品,并在总体质量限制下,达到总价值最优化。
背包问题最早由著名的十字军和维特根斯坦于末世纪四十年代被首先提出,他们认为它可以用来解决在野外战斗期间士兵装备配置问题。
在现代,当我们一定时间限制和资源限制的情况下做出最佳选择时,背包问题都会被广泛应用。
同时,它也被用来解决货币准备、电子商务中的物品搭配和货箱装箱等问题。
二、婪算法求解背包问题贪婪算法是一种能够有效解决搜索问题的算法,它总是在当前可行解中选择最优解。
这种算法的贪婪特性会让它比较容易实现,同时它也可以改善大多数最优时间复杂度和空间复杂度。
贪婪算法可以用来解决背包问题。
通过贪婪的决策选择,使得背包中的物品价值最大化。
贪婪算法的计算步骤如下:(1)根据背包容量,按比例选择价值较大且重量较轻的物品;(2)依次将价值最大的物品加入背包,直至规定重量到达为止;(3)检查最终获得的所有物品,保证它们尽可能满足重量限制。
三、lab中贪婪算法求解背包问题对于资源约束来说,lab中贪婪算法可以用来解决最优解问题。
lab中的贪婪算法可以用来求解背包问题,可以提高效率,提高求解的背包问题的精确度。
首先,可以将背包问题转化成一个更容易理解的数学模型:约束条件:质量:W=∑wi价值:V=∑xi其中,W为背包的总质量,V为背包的总价值,wi为第i个物品的质量,xi为第i个物品的价值。
设计算法:(1)根据约束条件取出有效物品,并且计算出每个物品的价值和质量比值;(2)按从大到小的价值比值顺序选择有效物品,并继续计算总的质量和价值;(3)当背包质量达到预定的容量时,停止选择,输出最终获得的最佳物品组合。
四、贪婪算法求解背包问题的实际应用贪婪算法求解背包问题在资源优化中有着很大的应用前景。
它可以用于供应链管理、资本规划、生产计划等领域,提高企业绩效,降低企业花销,从而改善企业生产力。
0-1背包问题动态规划和贪心法实现
算法设计与分析实验报告实验二 0-1背包问题院系:班级:计算机科学与技术学号:姓名:任课教师:成绩:湘潭大学2016年5月实验二0-1背包问题一. 实验内容分别编程实现动态规划算法和贪心法求0-1背包问题的最优解,分析比较两种算法的时间复杂度并验证分析结果。
二.实验目的1、掌握动态规划算法和贪心法解决问题的一般步骤,学会使用动态规划和贪心法解决实际问题;2、理解动态规划算法和贪心法的异同及各自的适用范围。
三. 算法描述/*动态规划 0-1背包问题算法如下*/Template<class Type>Void Knapsack(Type v,int w,int c,int n,Type ** m){int jMax = min(w[n] - 1,c);For(int j = 0;j <= jMax;j++){m[n][j] = 0;}For(int j = w[n];j <= c;j++){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++) m[i][j] = m[i+1][j];For(int j = w[i];j <= c;j++) min[i][j] = max(m[i+1][j],m[i+1][j-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]);}Template<class Type>Void Traceback(Type**m,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;}按上述算法Knapsack计算后m[1][c]给出所要求的0-1背包问题的最优解。
背包问题 实验报告
实验报告课程名称:算法设计与分析实验名称:解0-1背包问题任课教师:王锦彪专业:计算机应用技术班级: 2011 学号: ****** 姓名:严焱心完成日期: 2011年11月一、实验目的:掌握动态规划、贪心算法、回溯法、分支限界法的原理,并能够按其原理编程实现解决0-1背包问题,以加深对上述方法的理解。
二、实验内容及要求:1. 要求分别用动态规划、贪心算法、回溯法和分支限界法求解0-1背包问题;2. 要求显示结果。
三、实验环境和工具:操作系统:Windows7开发工具:Eclipse3.7.1 jdk6开发语言:Java四、实验问题描述:0/1背包问题:现有n 种物品,对1<=i<=n ,第i 种物品的重量为正整数W i ,价值为正整数V i ,背包能承受的最大载重量为正整数C ,现要求找出这n 种物品的一个子集,使得子集中物品的总重量不超过C 且总价值尽量大。
动态规划算法描述: 根据问题描述,可以将其转化为如下的约束条件和目标函数:⎪⎩⎪⎨⎧≤≤∈≤∑∑==)1}(1,0{C max 11n i x x w x v ini i i ni ii寻找一个满足约束条件,并使目标函数式达到最大的解向量),......,,,(321n x x x x X =,使得C 1∑=≤n i i i x w ,而且∑=ni i i x v 1达到最大。
0-1背包问题具有最优子结构性质。
假设),......,,,(321n x x x x 是所给的问题的一个最优解,则),......,,(32n x x x 是下面问题的一个最优解:∑∑==⎪⎩⎪⎨⎧≤≤∈-≤n i i i ini i i x v n i x x w x w 2211max )2}(1,0{C 。
如果不是的话,设),......,,(32n y y y 是这个问题的一个最优解,则∑∑==>n i n i i i i i x v y v 22,且∑=≤+n i i i y w x w 211C 。
背包问题实验报告
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)根据计算最优值时得到的信息,构造最优解。
算法设计和分析实验四:贪心算法求解背包问题
实验五:贪心算法求解背包问题实验内容应用贪心算法求解离散背包问题,分析时间复杂度。
有一个承重为W的背包和n个物品,它们各自的重量和价值分别是wi和vi (1<=i<=n),设求这些物品中最有价值的一个子集。
如果每次选择某一个物品的时候,只能全部拿走,则这一问题称为离散(0-1)背包问题;如果每次可以拿走某一物品的任意一部分,则这一问题称为连续背包问题。
算法思想•动态规划的思想:–对较小的子问题进行一次求解,并把结果记录下来,然后利用较小问题的解,求解出较大问题的解,直到求解出最大问题的解。
–引进一个二维数组ch[MAX][MAX],用ch[i][j]记录CH1与CH2的LCS的长度,b[i][j]记录ch[i][j]是通过哪一个子问题的值求得的,以决定搜索的方向。
我们是自底向上进行递推计算,那么在计算ch[i,j]之前,ch[i-1][j-1],ch[i-1][j]与ch[i][j-1]均已计算出来。
此时我们根据CH1 [i] = CH2[j]还是CH1[i] !=CH2[j],就可以计算出ch[i][j]。
算法length(string CH1,string CH2,int b[MAX][MAX])//用于构建动态数组//输入:两字符窜//输出:最长公共子序列for(i=1;i<=ch1Len;i++)//二重循环求解for(int j=1;j<=ch2Len;j++){if(CH1[i-1]==CH2[j-1])//相等字符{ch[i][j]=ch[i-1][j-1]+1;b[i][j]=0;}else if(ch[i-1][j]>=ch[i][j-1])//上比较大{ch[i][j]=ch[i-1][j];b[i][j]=1;}else//左比较大{ch[i][j]=ch[i][j-1];b[i][j]=-1;}}printCS(int b[MAX][MAX],string x,int i,int j) //回溯求出最长子序列输出//输入:标记数组//输出:最长子序列if(i == 0 || j == 0)//边界,返回return;if(b[i][j] == 0){printCS(b, x, i-1, j-1);//左上cout<<x[i-1]<<" ";}else if(b[i][j] == 1)printCS(b, x, i-1, j);//上elseprintCS(b, x, i, j-1);//左源程序//应用贪心算法求解离散背包问题#include<iostream>using namespace std;#define MAX 100//结构体struct Elem{double W;double V;double P;int number;};//顺序表struct SqList{Elem *elem;int length;int listsize;};//构造一个空的线性顺序表void InitList_Sq(SqList &L){L.elem=(Elem *)malloc(100*sizeof(Elem)); L.length=0;L.listsize=100;}//******************************** //构造背包,顺序表//******************************void input(SqList &L){cout<<"请输入物品的个数:";cin>>L.length;for(int i=0;i<L.length;i++){cout<<"请输入第"<<i+1<<"个物品的重量和价值:";cin>>L.elem[i].W>>L.elem[i].V;L.elem[i].P=L.elem[i].V/L.elem[i].W;cout<<"价值比为:"<<L.elem[i].P<<endl;L.elem[i].number=i+1;}}//*********************************//插入排序由大到小//*******************************void inser(SqList &L){Elem inserter;int index;//inserter待插入合适位置的元素,index指示插入位置for(int pass=1;pass<L.length;pass++){//共比较size-1轮inserter=L.elem[pass];//第pass轮时,待插入的对象是a[pass] index=pass-1;while(index>=0&&inserter.P>L.elem[index].P){ //寻找插入位置L.elem[index+1]=L.elem[index];index--;//指针前移,再比较}L.elem[index+1]=inserter;//跳出while时,找到插入位置}//end of forcout<<"按照价值比由大到小排列的顺序为:";for(pass=0;pass<L.length;pass++)cout<<L.elem[pass].number<<" ";cout<<endl;}//*************************************************8 //背包程序//采用贪心算法//根据价值和重量的比来实现贪心算法//************************************************ void bag(SqList L){double w,sumV=0,sumW=0;int list[MAX],a=0;cout<<"请输入背包承重量W:";cin>>w;inser(L);for(int i=0;i<L.length;i++){while(sumW+L.elem[i].W<=w){sumW=sumW+L.elem[i].W;sumV=sumV+L.elem[i].V;list[a++]=L.elem[i].number;}}cout<<"最后包里的总重量为:"<<sumW<<endl; cout<<"最后包里的总价值为:"<<sumV<<endl; cout<<"放到背包中的物品的序号列表为:"; for(i=0;i<a;i++){cout<<list[i]<<" ";}}int main(){cout<<"贪心算法求解背包问题"<<endl;SqList L;InitList_Sq(L);input(L);bag(L);return 0;}实验结论1、运行截图查找最长公共子序列长度时的动态规划两个for循环,时间复杂度为O(n*n)。
贪心算法背包问题
《算法设计与分析》实验报告2015-2016年第2学期实验班级:学生姓名:学号:指导老师:信息工程学院实验项目名称:贪心算法背包问题实验日期:2016年4月12日一、实验类型:□√验证性□设计性二、实验目的1、掌握背包问题的算法2、初步掌握贪心算法三、实验内容及要求问题描述:与0-1背包问题相似,给定n种物品和一个背包。
物品i的重量是wi,其价值为vi,背包的容量为c。
与0-1背包问题不同的是,在选择物品i装入背包时,背包问题的解决可以选择物品i的一部分,而不一定要全部装入背包,1< i < n。
四、实验步骤#include "iostream.h"#include "stdio.h"#include <cstdlib>struct stone{ int name;int weight;//物品的剩余重量int weight_t;//物品的重量float benefit;//物品的价值//float b;};void sort(stone *data,int num){if(num<1)return;int low=0,high=num;stone key_s=data[low];float key=(float)key_s.benefit/key_s.weight;int empty=low;while(low<high){ if(low==empty){ while((data[high].benefit/data[high].weight<key) &&(high>low)){ high--;}if(data[high].benefit/data[high].weight>=key){ data[low]=data[high];empty=high;}}else if(high==empty) {while((data[low].benefit/data[low].weight>=key)&&(low<h igh)){ low++; }if(data[low].benefit/data[low].weight<key){ data[high]=data[low];empty=low; }}}data[empty]=key_s;if(empty>1)sort(data,empty-1);if(num-empty-1>0)sort(data+empty+1,num-empty-1);}void inputstone(stone *bag,int num){ for(int i=0;i<num;i++){ bag[i].name=i+1;printf("请输入第%d号物品的重量:",i+1); scanf("%d",&bag[i].weight);if (bag[i].weight<=0){printf("物品的重量必须大于0!\n");} printf("请输入第%d号物品的价值:",i+1); scanf("%f",&bag[i].benefit);if (bag[i].benefit<=0){printf("物品的价值必须大于0!\n");}bag[i].weight_t=bag[i].weight;}}int main(int argc, char* argv[]){ int i;int num=0;int weight=0;float benefit=0;stone *bag;do{ printf("请输入背包可容纳的重量:"); scanf("%d",&weight);if (weight<=0)printf("背包可容纳的重量必须大于0!\n"); }while(weight<=0);do{ printf("请输入物品的数量:");scanf("%d",&num);if (num<=0)printf("物品数量必须大于0!\n");}while(num<=0);bag=new stone[num];inputstone(bag,num);sort(bag,num-1);for(i=0;i<num&&weight>0;i++){ stone *temp=bag+i;if(weight>=temp->weight){ weight-=temp->weight;temp->weight=0;benefit+=temp->benefit;continue;}else{ temp->weight-=weight;weight=0;benefit+=(temp->benefit*(1-(float)temp->weight/temp->we ight_t));break;} }printf("物品种类放入的比例每单位效益\n");for(i=0;i<num;i++){ stone *temp=bag+i;printf("%d类物品",temp->name);printf("\t\t%.2f\t\t",(temp->weight_t-temp->weight)/(fl oat)temp->weight_t);printf(" %.4f\n",temp->benefit/(float)temp->weight_t) ;}printf("总效益:%.2f",benefit);delete bag;getchar();system("PAUSE");return EXIT_SUCCESS;return 0;}五、实验结果1、实验图形2、结果分析如上面第一个图所示当输入背包可容纳的重要为21,输入物品的数量为3,输入第1号物品的重量为8,输入第1号物品的价值为12,输入第2号物品的重量为9,输入第2号物品的价值为16,输入第3号物品的重量为4,输入第3号物品的价值为15,则可以得出总效益为43.00。
背包问题问题实验报告(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。
算法实验报告01背包问题
工业大学计算机科学与软件学院算法分析与设计实验报告实验:0/1背包问题:学号:班级:"0-1"背包问题的动态规划算法一、实验目的与要求:熟悉C/C++语言的集成开发环境;通过本实验加深对贪心算法、动态规划和回溯算法的理解。
二、实验容:掌握贪心算法、动态规划和回溯算法的概念和基本思想,分析并掌握"0-1"背包问题的三种算法,并分析其优缺点。
三、实验程序:#include"stdio.h"int n=5;int w[]={0,3,2,1,4,5};int v[]={0,25,20,15,40,50};int x[5];int V[6][7];int C=6;void main(void){int i,j;for(i=0;i<=n;i++)V[i][0]=0;for(j=0;j<=C;j++)V[0][j]=0;for(i=1;i<=n;i++){for(j=1;j<=C;j++){if(j<w[i])V[i][j]=V[i-1][j];else{if(V[i-1][j]>V[i-1][j-w[i]]+v[i])V[i][j]=V[i-1][j];elseV[i][j]=V[i-1][j-w[i]]+v[i];}}}//以上构造动态规划表j=C;for(i=n;i>0;i--){if(V[i][j]>V[i-1][j]){x[i]=1;j=j-w[i];}elsex[i]=0;}printf("动态规划表如下:\n");for(i=0;i<6;i++){for(j=0;j<7;j++){printf("%8d",V[i][j]);}printf("\n");}printf("装入背包物品:\n");for(i=0;i<6;i++)printf("%4d",x[i]);printf("\n背包取得最大值:\n");printf("%4d\n",V[n][C]);}三、实验结果:四、实验分析:这次实验用到的是动态规划法,0/1背包问题用动态规划法首先要构造动态规划表,用三个for语句实现;根据动态规划表每行的最大值变化确定每个元素的装入与否,逐步确定出装入背包的物品,背包容量的最大值也就是动态规划表最右下角。
贪心法求解背包问题
问题描述
•
已知有n种物品和一个可容纳M重量的背包,每种物品i的重 量为。假定将物品i的一部分放入背包就会得到的效益,这里,, 。显 然,由于背包容量是M,因此,要求所有选中要装入背包的物品总重 量不得超过M.。如果这n件物品的总重量不超过M,则把所有物品装 入背包自然获得最大效益。现需解决的问题是,在这些物品重量的和 大于M的情况下,该如何装包,使得得到更大的效益值。由以上叙述, 可将这个问题形式表述如下: p i xi • 极 大 化目标函数 1i n • 约束条件 wi xi M • 1i n
0 xi 1, pi 0, wi 0,1 i n
算法分析
•
首先需确定最优的量度标准。这里考虑三种策略: • 策略1:按物品价值p降序装包, • 策略2:按物品重w升序装包 • 策略3:按物品价值与重量比值p/w的降序装包 分别以上面三种策略分别求以下情况背包问题的解: • n=7,M=15, 7 • ( p1 ,, p) =(10,5,15,7,6,18,3) • ( w1 ,, w7)=(2,3,5,7,1,4,1)
结果
The end,thank you!
请提问!
与其他算法比较
• 1.贪心法:处理问题的速度快,思想简单。使用该方法的 必要条件是寻找好的贪心法则。不足之处在于很多时候它 只能求的似优解,却不能求的最优解 • 2.动态规划法:可以求解最优解,重点在于徐兆最优决策 序列但是速度较慢。 • 3.分支限界法:可以求解最优解,重点在于寻找限界值。 易求最优解,但是空间花费较高,效率不是很高。 • பைடு நூலகம்择哪一种算法,不仅要根据问题本身还需要考虑到其他 因素,例如时间复杂度,空间复杂度,易求解等等因素。
贪心算法实验报告
贪心算法实验报告实验报告题目实验四贪心算法开课实验室:数学实验室指导老师:韩逢庆时间:2011.12 学院:理学院专业:信息与计算科学班级:2009级2班姓名:古月学号:09180230一、实验目的1(加深学生对贪心算法设计方法的基本思想、基本步骤、基本方法的理解与掌握;2(提高学生利用课堂所学知识解决实际问题的能力;3(提高学生综合应用所学知识解决实际问题的能力。
二、实验内容题目见P143:4-16,4-23.三、实验要求(1)用分治法求解最少加油次数和最少硬币个数问题;(2 )再选择自己熟悉的其它方法求解本问题;(3)上机实现所设计的所有算法;四、实验过程设计(算法设计过程)(1) 最少加油次数实验题目一辆汽车加满油以后可以行使n公里,旅途中有若干个加油站,设计一个有效算法,指出应在哪些加油站停靠加油,使沿路加油次数最少。
并证明算法能产生一个最优解。
过程设计贪心算法总是作出在当前看来最好的选择。
也就是说贪心算法并不从整体最优考虑,它所作出的选择只是在某种意义上的局部最优选择。
当然,希望贪心算法得到的最终结果也是整体最优的。
虽然贪心算法不能对所有问题都得到整体最优解,但对许多问题它能产生整体最优解。
比如说最少加油次数的问题。
在这个算法中,我采用的贪心算法的策略。
首先人机互动的设定加满油以后最长能够行使的距离,然后输入了各个站点之间的距离,在程序的设计中,首先检查了程序的可行性。
要是遇到当某两个站点之间的距离大于汽车一次加油以后所能够行使的最大距离时,我们认为此问题是不可行的。
这个在实际情况中也是很容易理解的。
然后在满足可行性条件下,依次采用贪心算法对问题得以实现。
采用s这个来保存现在车里面留下的油,当此时留下的有能够行驶完这一站点到下一站点之间的距离是,在这一站点的时候就不加油。
但是若不能行使完这一段路程的时候,就加满油。
核心算法如下:for(i=0,s=0;i<n;i++){s=s+a[i];if(s>n){sum++;s=a[i];}}(2) 最少硬币个数问题实验题目考虑下面的用最少硬币个数找出n分钱的问题:当使用2角5分,1角,5分和1分四种硬币面值时,设计一个找n分钱的贪心算法,并证明算法能产生最优解。
基于朴素贪心算法的背包问题解决方案
基于朴素贪心算法的背包问题解决方案背包问题是一类经典的组合优化问题,它的一般形式描述为:有一个固定大小的背包,和一些物品,每个物品都有自己的价值和大小,需要选出一些物品装入背包中,使得装进去的物品价值最大化,同时又不能超出背包容量的限制。
这个问题在实际生活中有很多应用,比如在货物的装载和运输、在零售商的库存管理、在网页推荐系统等等。
解决背包问题的方法有很多,其中比较经典的是基于动态规划的解法,但是这种解法需要使用大量的存储空间,如果物品数量很大的话,计算复杂度也会很高。
因此本文将介绍一种基于朴素贪心算法的背包问题解决方案。
一、背包问题的数学模型在介绍具体的解决方案之前,我们需要先来看一下背包问题的数学模型。
假设我们有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$为物品的数量。
贪心算法实现背包问题算法设计与分析实验报告
算法设计与分析实验报告实验名称 贪心算法实现背包问题 评分 实验日期 年 月 日 指导教师 姓名 专业班级 学号一.实验要求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件物品的效益值和重量。
2贪心算法解决部分背包问题
2贪心算法解决部分背包问题一、实验目的学习掌贪心算法法思想。
二、实验内容用贪心法解决部分背包问题。
给定n种物品和一个背包。
物品i的重量是Wi,其价值为pi,背包的容量为M,将物品i的一部分xi放入背包会得到pi xi的效益。
应如何选择装入背包的物品,使得装入背包中物品的总价值最大?给出具体的装包方案。
在选择装入背包的物品时,对每种物品i,可以整件装入背包、不装入背包或部分装入背包。
但不能将物品i装入背包多次。
四、需求分析对于给定n种物品和一背包。
在容量最大值固定的情况下,要求装入的物品价值最大化。
五、基本思想:贪婪法是解决最优化问题时的一种简单但适用范围有限的策略。
总是对当前的问题作最好的选择,也就是局部寻优。
最后得到整体最优。
总是选择单位价值最高的物品。
六、详细设计#include<iostream>using namespace std;struct _Object//物品结构体{int Value;//物品价值int Weight;//物品重量int AveValue;//物品单位价值float Num;//物品可以放入的数量void knaspsack(int n,float M,_Object object[]){ //n为物品个数,M为背包容量int i;float C=M;for(i=0;i<n;i++){object[i].Num=0;//初始化放入背包的物品为0if(object[i].Weight>C)break;//当物品重量大于背包容量时else//小于时{object[i].Num=1;//物品i放入一件C-=object[i].Weight;//背包容量减小}}if(i<=n)//当不能放入整个物品时,选取物品一部分放入object[i].Num=C/object[i].Weight;for(i=0;i<n;i++){if(object[i].Num>0)cout<<"重量为: "<<object[i].Weight<<" 价值为: "<<object[i].Value<<" 的物品放入"<<object[i].Num<<" 件"<<endl;}}void SortObject(_Object object[],int n)//将各个物品按单位价值进行排序{int j;_Object temp;int i;for(i=0;i<n;i++)object[i].AveValue=object[i].Value/object[i].Weight;//各个物品的单位价值for(i=0;i<n-1;i++)//根据物品的单位价值对物品进行从大到小的冒泡排序{for(j=0;j<n-i-1;j++){if(object[j].AveValue<object[j+1].AveValue){temp=object[j];object[j]=object[j+1];object[j+1]=temp;}}}}int main(){_Object object[4];//4个物品int M=9;//背包容量为15object[0].Weight=2;object[0].Value=3;object[1].Weight=3;object[1].Value=4;object[2].Weight=4;object[2].Value=5;object[3].Weight=5;object[3].Value=7;SortObject(object,4);knaspsack(4,M,object);}七、结果分析:对于0-1背包问题,贪心算法之所以不能得到最优解是因为在这种情况下,它无法保证最后能将背包装满,部分闲置的背包空间,使每公斤背包的价值降低了。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
算法设计与分析实验报告实验名称贪心算法实现背包问题评分实验日期年月日指导教师姓名专业班级学号一.实验要求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件物品的效益值和重量。
M是背包的容量大小,而x(1:n)是解向量real P(1:n),W(1:n),X(1:n),M,cu;integer i,n;X←0 //将解向量初始化为零cu←M //cu是背包剩余容量for i←1 to n doif W(i)>cu then exit endifX(i) ←1cu←cu-W(i)repeatif i≤n then X(i) ←cu/ W(i)endifend GREEDY-KNAPSACKprocedure prim(G,)status←“unseen” // T为空status[1]←“tree node” // 将1放入Tfor each edge(1,w) dostatus[w]←“fringe” // 找到T的邻接点dad[w] ←1; //w通过1与T建立联系dist[w] ←weight(1,w) //w到T的距离repeatwhile status[t]≠“tree node” dopick a fringe u with min dist[w] // 选取到T最近的节点status[u]←“tree node”for each edge(u,w) do修改w和T的关系repeatrepeat2.Prim算法PrimMST(G,T,r){//求图G的以r为根的MST,结果放在T=(U,TE)中InitCandidateSet(…);//初始化:设置初始的轻边候选集,并置T=({r},¢) for(k=0;k<n-1;k++){ //求T的n-1条树边(u,v)=SelectLiShtEdge(…);//选取轻边(u,v);T←T∪{(u,v)};//扩充T,即(u,v)涂红加入TE,蓝点v并人红点集UModifyCandidateSet(…); //根据新红点v调整候选轻边集}四.程序代码1.背包问题贪心算法#include <iostream.h>struct goodinfo{float p; //物品效益float w; //物品重量float X; //物品该放的数量int flag; //物品编号};//物品信息结构体void Insertionsort(goodinfo goods[],int n){int j,i;for(j=2;j<=n;j++){goods[0]=goods[j];i=j-1;while (goods[0].p>goods[i].p){goods[i+1]=goods[i];i--;}goods[i+1]=goods[0];}}//按物品效益,重量比值做升序排列void bag(goodinfo goods[],float M,int n){float cu;int i,j;for(i=1;i<=n;i++)goods[i].X=0;cu=M; //背包剩余容量for(i=1;i<n;i++){if(goods[i].w>cu)//当该物品重量大与剩余容量跳出break;goods[i].X=1;cu=cu-goods[i].w;//确定背包新的剩余容量}if(i<=n)goods[i].X=cu/goods[i].w;//该物品所要放的量for(j=2;j<=n;j++){goods[0]=goods[j];i=j-1;while (goods[0].flag<goods[i].flag){goods[i+1]=goods[i];i--;}goods[i+1]=goods[0];}cout<<"最优解为:"<<endl;for(i=1;i<=n;i++){cout<<"第"<<i<<"件物品要放:";cout<<goods[i].X<<endl;}}void main(){cout<<"|--------运用贪心法解背包问题---------|"<<endl; cout<<"|-------------------------------------|"<<endl; int j;int n;float M;goodinfo *goods;//定义一个指针while(j){cout<<"请输入物品的总数量:";cin>>n;goods=new struct goodinfo [n+1];//cout<<"请输入背包的最大容量:";cin>>M;cout<<endl;int i;for(i=1;i<=n;i++){ goods[i].flag=i;cout<<"请输入第"<<i<<"件物品的重量:";cin>>goods[i].w;cout<<"请输入第"<<i<<"件物品的效益:";cin>>goods[i].p;goods[i].p=goods[i].p/goods[i].w;//得出物品的效益,重量比 cout<<endl;}Insertionsort(goods,n);bag(goods,M,n);cout<<"press <1> to run agian"<<endl;cout<<"press <0> to exit"<<endl;cin>>j;}}2.Prim算法#include <stdio.h>#include <stdlib.h>#include <iostream.h>#define INFINITY INT_MAX#define MAX_VERTEX_NUM 20typedef int VRType;typedef int InfoType;typedef char VerTexType;typedef struct ArcCell{VRType adj;InfoType *info;}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{VerTexType vexs[MAX_VERTEX_NUM];AdjMatrix arcs;int vexnum, arcnum;}MGraph;typedef struct{VerTexType adjvex;VRType lowcost;}closedge[MAX_VERTEX_NUM];void CreateGraph(MGraph &G);void MiniSpanTree_PRIM(MGraph G, VerTexType u); int LocateVex(MGraph G, VerTexType u);int minimum(closedge close);void main( void ){int i, j;MGraph G;CreateGraph(G);for(i = 0; i < G.vexnum; i++){for(j = 0; j < G.vexnum; j++){cout<<G.arcs[i][j].adj;cout<<" ";}cout<<endl;}MiniSpanTree_PRIM(G, 'a');}void CreateGraph(MGraph &G){int weigh;int i, j = 0, k = 0;char hand, tide;cout<<"input the number for vexnum and arcnum:";cin>>G.vexnum>>G.arcnum;for(i = 0; i < G.vexnum; i++){for(j = 0; j < G.vexnum; j++)G.arcs[i][j].adj = 88;}cout<<endl;cout<<"input"<<G.vexnum<<"char for vexs:";for(i=0; i < G.vexnum; i++)cin>>G.vexs[i];cout<<endl;cout<<"input"<<G.arcnum<<"arc(char,char,weigh):"<<endl; j = 0;k = 0;for(i=0; i < G.arcnum; i++){cout<<i<<":";cin>>hand;cin>>tide;cin>>weigh;while (hand != G.vexs[j])j++;while (tide != G.vexs[k])k++;G.arcs[j][k].adj = weigh;G.arcs[k][j].adj = weigh;j = 0;k = 0;cout<<endl;}}void MiniSpanTree_PRIM(MGraph G,VerTexType u){int i, j, k = 0;closedge close;k = LocateVex ( G, u );for ( j = 0; j < G.vexnum; j++ ){if (j != k){close[j].adjvex = G.vexs[k];close[j].lowcost = G.arcs[k][j].adj;}}close[j].lowcost = 88;close[j].adjvex = '\0';close[k].lowcost = 0;close[k].adjvex = u;for (i = 1; i < G.vexnum; i++){k = minimum(close);cout<<close[k].adjvex;cout<<"---->";cout<<G.vexs[k]<<" ";cout<<close[k].lowcost<<endl;close[k].lowcost = 0;for (j=0; j<G.vexnum; j++){if (G.arcs[k][j].adj < close[j].lowcost) {close[j].adjvex = G.vexs[k];close[j].lowcost = G.arcs[k][j].adj;}}}}int LocateVex(MGraph G, VerTexType u){int k = 0;while(G.vexs[k++] == u)return k-1;return 0;}int minimum(closedge close){int j1=0, client = 88, j2;while(close[j1].adjvex != '\0'){if (client > close[j1].lowcost && close[j1].lowcost != 0) {client = close[j1].lowcost;j2 = j1;}j1++;}return j2;}六.实验结果1. 背包问题贪心算法2. Prim算法。