C++应用贪心算法求解背包问题

合集下载

经典贪心题

经典贪心题

贪心算法是一种在解决问题的过程中追求局部最优的算法,对于一个有多种属性的事物来说,贪心算法会优先满足某种条件,追求局部最优的同时希望达到整体最优的效果。

以下是一些经典的贪心算法问题:1. 背包问题:给定一组物品,每个物品都有自己的重量和价值,背包的总容量有限。

贪心算法需要选择物品以最大化背包中物品的总价值,同时不超过背包的总容量。

这种问题可以有多种变体,例如分数背包问题和完全背包问题。

2. 硬币找零问题:给定一组硬币的面值和数量,以及需要找零的金额。

贪心算法需要选择硬币以最小化找零的总数量。

这个问题可以通过从大到小排序硬币,并从最大面值的硬币开始选择,直到找零的金额达到所需的总金额。

3. 区间选点问题:给定一系列闭区间,每个闭区间都有一个起始点和结束点。

贪心算法需要选择尽量少的点,使得每个闭区间内至少有一个点被选中。

这个问题可以通过对结束点进行排序,并从左到右选择结束点,直到下一个要选择的结束点与上一个选择的结束点之间的距离大于当前选择的结束点与上一个选择的结束点之间的距离为止。

4. 区间覆盖问题:给定一系列闭区间,贪心算法需要选择尽量少的区间,使得所有区间都被覆盖。

这个问题可以通过对每个闭区间的左端点进行排序,并从左到右选择左端点,直到下一个要选择的左端点与上一个选择的左端点之间的距离大于当前选择的左端点与上一个选择的左端点之间的距离为止。

5. 排班问题:给定一组员工和他们的班次需求,以及一组工作日的日程安排。

贪心算法需要为员工分配班次,以最小化总工作时间并满足所有工作日的需求。

这个问题可以通过从可用的班次中选择最长的班次,并从左到右分配员工,直到所有员工都被分配到一个班次为止。

这些问题是贪心算法的经典示例,它们展示了贪心算法在解决优化问题中的广泛应用。

《信息学奥赛一本通》:第9章 第2节 动态规划背包问题(C++版)

《信息学奥赛一本通》:第9章  第2节 动态规划背包问题(C++版)
f[n][m]即为最优解。
【参考程序】
#include<cstdio> using namespace std;
const int maxm = 201, maxn = 31;
int m, n;
int w[maxn], c[maxn];
int f[maxn][maxm];
int main()
{
scanf("%d%d",&m, &n);
for (int i=1; i <= n; i++)
//设f(v)表示重量不超过v公斤的最大价值
for (int v = m; v >= w[i]; v--)
if (f[v-w[i]]+c[i]>f[v])
f[v] = f[v-w[i]]+c[i];
printf("%d",f[m]);
// f(m)为最优解
【例9-12】、完全背包问题 【问题描述】
设有n种物品,每种物品有一个重量及一个价值。但每种物品的数量是无限 的,同时有一个背包,最大载重量为M,今从n种物品中选取若干件(同一种物品 可以多次选取),使其重量的和小于等于M,而价值的和为最大。
【输入格式】
第一行:两个整数,M(背包容量,M<=200)和N(物品数量,N<=30); 第2..N+1行:每行二个整数Wi,Ci,表示每个物品的重量和价值。 【输出格式】
第九章 动态规划
第二节 背包问题
第二节 背包问题
一、01背包问题 问题:
有N件物品和一个容量为V的背包。第i件物品的费用(即体积,下同)是w[i], 价值是c[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量, 且价值总和最大。 基本思路:

遗传算法求解背包问题

遗传算法求解背包问题

遗传算法求解背包问题程序实现一、背包问题描述背包问题是著名的NP 完备类困难问题,对这个问题的求解前人已经研究出了不少的经典的方法,对该问题确实能得到很好的结果。

近年来蓬勃发展起来的遗传算法已被广泛地应用于优化领域,其全局最优性、可并行性、高效性在函数优化中得到了广泛地应用遗传算法克服了传统优化方法的缺点,借助了大自然的演化过程,是多线索而非单线索的全局优化方法,采用的是种群和随机搜索机制. 本程序将遗传算法应用于背包问题。

二、实验程序1、编程语言:C++2、开发环境:Microsoft Visual Studio 20053、程序整体流程:步1初始化过程1. 1确定种群规模scale、杂交概率pc、变异概率pm、染色体长度chN及最大进化代数maxgen。

1. 2取x1′(0) = u (0 ,1) , x2′(0) = u (0 ,1) , …, xchN′(0) = u (0 ,1) ,其中函数u (0 ,1) 表示随机地产生数0 或1 ,则x (0) = ( x1 (0) , x2 (0) ,⋯, xN (0) ) .若不满足约束条件,则拒绝接受. 由(1. 2) 重新产生一个新的染色体; 如果产生的染色体可行,则接受它作为种群的一名成员,经过有限次抽样后, 得到scale个可行的染色体xj (0) , j =1 ,2 , ⋯, M ,设xj (0) 的染色体编码为vj (0) ,并记为v (0) = ( v1 (0) , ⋯, vchN (0) ) .1. 3计算各个染色体的适值1. 4 置k = 0步2选择操作2. 1采用转轮法选择下一代。

.步3杂交变异操作3. 1 事先定义杂交操作的概率pc ,为确定杂交操作的父代,从j = 1 到M 重复以下过程:从[0 ,1 ] 中产生随机数r ,若r < pc ,则选择cj′( k)作为一个父代.3. 2 产生两个[1 , N ] 上的随机整数i 、j ,变异的结果为染色体vj′( k)的第i 位基因的值变为其第j 位基因的值,同样将染色体的vj′( k)第j 位基因的值变为其第i 位基因的值.3. 3 检验该染色体的可行性,若可行则作为变异的结果;如不可行,重复3. 2 直至该染色体可行.3. 4 事先定义变异概率pm ,对经过杂交操作的中间个体进行变异操作: ,如果r < pm ,则选择vi″( k) 作为变异的父代.3. 5 产生一个[1 , N ] 上的随机整数i ,及随机地产生数0 或1 , 记为b , 变异的结果为染色体vi″( k) 的第i 位基因的值变为b.3. 6 检验该染色体的可行性,若可行则作为变异的结果:如不可行,重复3. 5 直至该染色体可行.3. 7 计算新个体的适应值,并把它们同时放回,和步2 选择操作中剩余的个体一起构成新一代种群v ( k + 1) = { v1 ( k + 1) , v2 ( k + 1) , ⋯, vM ( k + 1) } .步4 终止检验如果达到最大进化代数maxgen 则终止演化,否则置k : = k + 1 ,转步2.4、程序流程图程序流程图5、程序代码1)主程序代码:KnapsacksProblem.cpp文件#include "GAonKP.h"#include <iostream>using namespace std;void main(){FILE* fp;CGAonKP gakp;int scale; //种群规模double MaxWeight; //背包允许最大财宝质量double pc; //杂交概率double pm; //变异概率int maxgen; //最大进化代数char filename[256];cout<<"遗传算法解决背包问题程序使用说明:"<<endl;cout<<"1、该背包问题采用遗传算法"<<endl;cout<<"2、-1编码的方法,其中代表选中所对应的物品,代表不选中该物品"<<endl;cout<<"3、背包允许最带重量,种群规模(解空间大小),";cout<<"杂交概率,变异概率,最大进化代数需自己给";cout<<"定,程序会提示输入"<<endl;cout<<"4、程序提供一个输入示例"<<endl;cout<<"5、输入文件可加单行或多行注释"<<endl;cout<<"例如:#添加单行注释内容#"<<endl;cout<<"例如:#添加多行注释内容"<<endl;cout<<" 添加多行注释内容#"<<endl;cout<<"6、输入文件头位置需指定物品个数为int型数据。

算法实验报告范文

算法实验报告范文

算法实验报告范文《算法设计与分析》实验报告班级姓名学号年月日目录实验一二分查找程序实现…………………………………………………………………03页实验二棋盘覆盖问题(分治法).…………………………………………………………08页实验三0-1背包问题的动态规划算法设计……………………………………………….11页实验四背包问题的贪心算法………………………………………………………………14页实验五最小重量机器设计问题(回溯法)………………………………………………17页实验六最小重量机器设计问题(分支限界法)…………………………………………20页指导教师对实验报告的评语成绩:指导教师签字:年月日2实验一:二分查找程序实现一、实验时间:2022年10月8日,星期二,第一、二节地点:J13#328二、实验目的及要求目的:1、用c/c++语言实现二分搜索算法。

2、通过随机产生有序表的方法,测出在平均意义下算法比较次数随问题规模的变化曲线,并作图。

三、实验环境平台:Win732位操作系统开发工具:Codeblock10.05四、实验内容对已经排好序的n个元素a[0:n-1],现在要在这n个元素中找出一特定元素某。

五、算法描述及实验步骤算法描述:折半查找法也称为二分查找法,它充分利用了元素间的次序关系,采用分治策略,可在最坏的情况下用O(logn)完成搜索任务。

它的基本思想是,将n个元素分成个数大致相同的两半,取a[n/2]与欲查找的某作比较,如果某=a[n/2]则找到某,算法终止。

如果某a[n/2],则我们只要在数组a的右半部继续搜索某。

二分搜索法的应用极其广泛,而且它的思想易于理解。

确定算法复杂度基本步骤:1、首先设定问题规模n;2、随即产生递增数列;3、在n个有序数中随机取一个作为待查找量,搜索之;4、记录查找过程中的比较次数,再次生成新的有序表并查找,记录查找次数,每个数组重复10次;5、改变问题规模n重复上述步骤2~4,n取100、200……1000;6、依实验数据作图,并与理论图作比较;7、二分搜索算法平均查找次数:问题规模为n时,平均查找次数为:A(n)=Int(logn)+1/2//Int()函数为向下取整3即二分搜索算法对于含有n个数据的有序表L平均作了约Int(logn)+1/2次的查找操作。

贪心算法求解最优解问题

贪心算法求解最优解问题

贪心算法求解最优解问题贪心算法是计算机科学领域中常用的一种算法。

它常常被用来求解最优解问题,如背包问题、最小生成树问题、最短路径问题等。

贪心算法解决最优解问题的基本思路是,每一步都选取当前状态下最优的解决方案,直到达到全局最优解。

在这篇文章中,我们将为大家深入探讨贪心算法求解最优解问题的基本思路、算法复杂度和应用场景等方面的知识。

基本思路贪心算法是一种基于贪心策略的算法。

其核心思想是,每一步都采用当前最优策略,以期最终达到全局最优解。

在贪心算法中,每个子问题的最优解一般都是由上一个子问题的最优解推导出来的。

因此,关键在于如何找到最优解。

具体而言,贪心算法一般由三部分组成,分别为:状态、选择和判断。

首先,需要明确当前问题的状态,即问题的规模和限制条件。

然后,在当前的限制条件下,我们需要从可能的方案中选择出最优的方案,并把这个选择作为解的一部分。

最后,需要判断选择是否符合问题的限制条件,是否达到全局最优解。

算法复杂度在进行算法分析时,我们需要考虑算法的时间复杂度和空间复杂度。

对于贪心算法而言,其时间复杂度一般是 O(nlogn) 或 O(n) 级别的,其中 n 表示问题的规模。

这种效率在实际应用中表现出了很高的稳定性和效率。

应用场景贪心算法通常应用于需要求解最优解问题的场景中。

例如:- 贪心算法可以用来求解背包问题。

在背包问题中,我们需要在限定的空间内选取最有价值的物品装入背包中以努力获得最大的收益。

在贪心策略下,我们只需要按单位重量价值从大到小的顺序进行选择,就可以得到最优解;- 贪心算法也可以用来求解最小生成树问题。

这个问题是指,在给定一个图的时候,我们需要选出一棵生成树,使得生成树上的所有边权之和最小。

在此问题中,我们可以将图上的边权按大小排序,然后顺序选择边直至生成树。

这样,我们可以得到与全局最优解很接近的解;- 贪心算法还可以用来求解最短路径问题。

在最短路径问题中,我们需要找到从一个节点到另一个节点的最短路径。

01背包问题c语言代码回溯法

01背包问题c语言代码回溯法

以下是使用C语言实现01背包问题的回溯法代码:```c#include <stdio.h>#include <stdlib.h>// 初始化背包struct knapsack {int maxWeight; // 背包最大承重int *items; // 物品数组int n; // 物品数量};// 定义物品重量、价值和数量int weights[] = {2, 2, 6, 5, 4};int values[] = {6, 3, 5, 4, 6};int quantities[] = {3, 2, 2, 1, 1};// 初始化背包最大承重和当前承重int maxWeight = 10;int currentWeight = 0;// 初始化最大价值为0int maxValue = 0;// 遍历物品数组void traverseItems(struct knapsack *knapsack, int index) { // 对于每个物品,遍历其数量for (int i = 0; i < knapsack->quantities[index]; i++) {// 如果当前物品可以放入背包装且当前承重不超过背包最大承重,计算放入该物品后的总价值,并更新最大价值if (currentWeight + weights[index] <= knapsack->maxWeight) {int currentValue = values[index] * knapsack->quantities[index];if (currentValue > maxValue) {maxValue = currentValue;}}// 回溯,将当前物品从背包装中移除,递归地尝试下一个物品knapsack->quantities[index]--;if (index < knapsack->n - 1) {traverseItems(knapsack, index + 1);}knapsack->quantities[index]++; // 恢复物品数量,以便下次遍历尝试放入其他物品}}// 主函数int main() {// 初始化背包装和物品数组struct knapsack knapsack = {maxWeight, weights, 5};knapsack.items = (int *)malloc(sizeof(int) * knapsack.n);for (int i = 0; i < knapsack.n; i++) {knapsack.items[i] = values[i] * quantities[i]; // 根据价值和数量计算物品价值,并存储在物品数组中}knapsack.n = quantities[4]; // 由于最后一个物品的数量为1,因此只需遍历前n-1个物品即可得到所有可能的结果// 使用回溯法求解01背包问题,返回最大价值traverseItems(&knapsack, 0);printf("The maximum value is %d.\n", maxValue);free(knapsack.items); // 释放内存空间return 0;}```希望以上信息能帮助到你。

贪心:钱币找零问题(C++)

贪⼼:钱币找零问题(C++)贪⼼是⼀种算法范例,它⼀点⼀点地构建解决⽅案,总是选择下⼀个提供最明显和最直接好处的部分。

因此,选择局部最优也会导致全局解的问题最适合贪⼼问题。

例如,考虑分数背包问题。

局部最优策略是选择权重⽐最⼤的项。

这个策略也导致了全局最优解。

假设1元、2元、5元、10元、20元、50元、100元的纸币分别有a,b,c,d,e,f,g张。

现在要⽤这些钱来⽀付m元,⾄少要⽤多少张纸币?⽤贪⼼算法的思想,每⼀次选择最⼤⾯值的钱币。

#include <iostream>#include <vector>#include <algorithm>using namespace std;vector<int> Num{ 3,0,2,1,0,3,5 }, Value{ 1,2,5,10,20,50,100 };int BagsQues(int money) {int sum = 0;for (int i = Value.size() - 1; i >= 0; --i) {int N = min(money / Value[i], Num[i]);money = money - N * Value[i];sum += N;if (money == 0)return sum;}return -1;}int main(){int money;cin >> money;int m = BagsQues(money);cout << m << endl;system("PAUSE");return0;}求出每张⾯额,⽤了多少张:#include <iostream>#include <vector>#include <tuple>#include <algorithm>using namespace std;vector<int> Num{ 3,0,2,1,0,3,5 }, Value{ 1,2,5,10,20,50,100 };vector<tuple<int, int> > BagsQues(int money) {int sum = 0;vector<tuple<int, int> > ch;for (int i = Value.size() - 1; i >= 0; --i) {int N = min(money / Value[i], Num[i]);money = money - N * Value[i];sum += N;if (N != 0) {ch.push_back({ Value[i], N });}if(money == 0)return ch;}ch.clear();ch.push_back({ -1, -1 });return ch;}int main(){int money;cin >> money;vector<tuple<int, int> > m = BagsQues(money);for (int i = 0; i < m.size(); ++i) {cout << get<0>(m[i]) << ":" << get<1>(m[i]) << endl; }system("PAUSE");return0;}。

动态规划算法--01背包问题

动态规划算法--01背包问题基本思想:动态规划算法通常⽤于求解具有某种最优性质的问题。

在这类问题中,可能会有许多可⾏解。

每⼀个解都对应于⼀个值,我们希望找到具有最优值的解。

动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若⼲个⼦问题,先求解⼦问题,然后从这些⼦问题的解得到原问题的解。

与分治法不同的是,适合于⽤动态规划求解的问题,经分解得到⼦问题往往不是互相独⽴的(即下⼀个⼦阶段的求解是建⽴在上⼀个⼦阶段的解的基础上,进⾏进⼀步的求解)。

若⽤分治法来解这类问题,则分解得到的⼦问题数⽬太多,有些⼦问题被重复计算了很多次。

如果我们能够保存已解决的⼦问题的答案,⽽在需要时再找出已求得的答案,这样就可以避免⼤量的重复计算,节省时间。

我们可以⽤⼀个表来记录所有已解的⼦问题的答案。

不管该⼦问题以后是否被⽤到,只要它被计算过,就将其结果填⼊表中。

这就是动态规划法的基本思路。

具体的动态规划算法多种多样,但它们具有相同的填表格式。

应⽤场景:适⽤动态规划的问题必须满⾜最优化原理、⽆后效性和重叠性。

1、最优化原理(最优⼦结构性质)最优化原理可这样阐述:⼀个最优化策略具有这样的性质,不论过去状态和决策如何,对前⾯的决策所形成的状态⽽⾔,余下的诸决策必须构成最优策略。

简⽽⾔之,⼀个最优化策略的⼦策略总是最优的。

⼀个问题满⾜最优化原理⼜称其具有最优⼦结构性质。

2、⽆后效性将各阶段按照⼀定的次序排列好之后,对于某个给定的阶段状态,它以前各阶段的状态⽆法直接影响它未来的决策,⽽只能通过当前的这个状态。

换句话说,每个状态都是过去历史的⼀个完整总结。

这就是⽆后向性,⼜称为⽆后效性。

3、⼦问题的重叠性动态规划将原来具有指数级时间复杂度的搜索算法改进成了具有多项式时间复杂度的算法。

其中的关键在于解决冗余,这是动态规划算法的根本⽬的。

动态规划实质上是⼀种以空间换时间的技术,它在实现的过程中,不得不存储产⽣过程中的各种状态,所以它的空间复杂度要⼤于其它的算法。

acm算法类型

ACM(ACM International Collegiate Programming Contest)是一个国际性的大学生计算机程序设计竞赛,涵盖了多个算法类型。

下面是一些常见的ACM算法类型:贪心算法(Greedy Algorithm):贪心算法通过每一步选择当前最优解,以期望达到全局最优解的算法。

在ACM竞赛中,贪心算法通常用于求解优化问题,如最小生成树、最短路径和调度问题等。

动态规划(Dynamic Programming):动态规划是一种将复杂问题分解为简单子问题并进行逐步求解的方法。

ACM竞赛中,动态规划常用于解决最优化问题,如背包问题、最长公共子序列和最短编辑距离等。

图论算法(Graph Algorithms):图论算法涉及到处理和分析图结构的问题。

在ACM竞赛中,图论算法常用于解决最短路径、最小生成树、网络流等问题,如Dijkstra算法、Floyd-Warshall 算法和最大流最小割算法等。

字符串算法(String Algorithms):字符串算法主要处理字符串操作和匹配问题。

在ACM竞赛中,字符串算法常用于解决字符串匹配、模式识别和字符串编辑等问题,如KMP算法、正则表达式和后缀树等。

数论算法(Number Theory Algorithms):数论算法涉及到整数和数字理论方面的计算问题。

在ACM竞赛中,数论算法常用于解决素数判定、最大公约数、快速幂等问题,如欧几里得算法和质因数分解等。

排序和搜索算法(Sorting and Searching Algorithms):排序和搜索算法用于处理数据的排序和查找问题。

在ACM竞赛中,常见的排序算法有快速排序、归并排序和堆排序,常见的搜索算法有二分搜索和广度优先搜索(BFS)等。

这些是ACM竞赛中常见的算法类型,但并不是全部。

ACM竞赛还涉及其他算法和数据结构,如树结构、并查集、位运算等。

为了在ACM竞赛中取得好的成绩,熟悉这些算法类型,并进行相关的训练和实践是非常重要的。

贪 心 算 法

贪心算法及几个常用的例题贪心算法:一、基本概念:所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。

也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解。

贪心算法没有固定的算法框架,算法设计的关键是贪心策略的选择。

必须注意的是,贪心算法不是对所有问题都能得到整体最优解,选择的贪心策略必须具备无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关。

所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。

二、贪心算法的基本思路:1.建立数学模型来描述问题。

2.把求解的问题分成若干个子问题。

3.对每一子问题求解,得到子问题的局部最优解。

4.把子问题的解局部最优解合成原来解问题的一个解。

三、贪心算法适用的问题贪心策略适用的前提是:局部最优策略能导致产生全局最优解。

实际上,贪心算法适用的情况很少。

一般,对一个问题分析是否适用于贪心算法,可以先选择该问题下的几个实际数据进行分析,就可做出判断。

四、贪心算法的实现框架从问题的某一初始解出发;while (能朝给定总目标前进一步)利用可行的决策,求出可行解的一个解元素;由所有解元素组合成问题的一个可行解;五、贪心策略的选择因为用贪心算法只能通过解局部最优解的策略来达到全局最优解,因此,一定要注意判断问题是否适合采用贪心算法策略,找到的解是否一定是问题的最优解。

几个经典的例子:一、定义什么是贪心算法呢?所谓贪心算法是指,在对问题求解时,总是做出在当前看来最好的选择。

也就是说,不从整体最优解出发来考虑,它所做出的仅是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解,但对范围相当广泛的许多问题都能产生整体最优解或整体最优解的近似解。

贪心算法的基本思路如下:1. .建立数学模型来描述问题。

2. 把求解的问题分成若干个子问题。

3. 对每个子问题求解,得到每个子问题的局部最优解。

4. 把每个子问题的局部最优解合成为原来问题的一个解。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验五 应用贪心算法求解背包问题
学院: 计算机科学与技术 专业:计算机科学与技术
学号: 班级: 姓名:

一、
实验内容:

背包问题指的是:有一个承重为W的背包和n个物品,它们各自的重量和价值分别是

i
w
和iv(1in),假设1niiWw,求这些物品中最有价值的一个子集。如果每次选择

某一个物品的时候,只能全部拿走,则这一问题称为离散(0-1)背包问题;如果每次
可以拿走某一物品的任意一部分,则这一问题称为连续背包问题。
二、算法思想:
首先计算每种物品单位重量的价值Vi/Wi,然后,依贪心选择策略,将尽可能多的单位
重量价值最高的物品装入背包。若将这种物品全部装入背包后,背包内的物品总重量未超过
C,则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直地进行下去,直
到背包装满为止。
三、实验过程:
#include
using namespace std;
struct goodinfo
{
float p; //物品效益
float w; //物品重量
float X; //物品该放的数量
int flag; //物品编号
};//物品信息结构体
void Insertionsort(goodinfo goods[],int n)//插入排序,按pi/wi价值收益进行排序,一般教材上
按冒泡排序
{
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{
if(goods[i].w{
goods[i].X=1;
cu-=goods[i].w;//确定背包新的剩余容量
}
else
{
goods[i].X=0;
}

for(j=2;j<=n;j++) /*按物品编号做降序排列*/
{
goods[0]=goods[j];
i=j-1;
while (goods[0].flag{
goods[i+1]=goods[i];
i--;
}
goods[i+1]=goods[0];
}
}
cout<<"最优解为:"<for(i=1;i<=n;i++)
{
cout<<"第"<cout<}
}
void main()
{
cout<<"|--------运用贪心法解背包问题---------|"<int j,n;
float M;
goodinfo *goods;//定义一个指针
while(j)
{
cout<<"请输入物品的总数量:";
cin>>n;
goods=new struct goodinfo [n+1];//
cout<<"请输入背包的最大容量:";
cin>>M;
cout<int i;
for(i=1;i<=n;i++)
{
goods[i].flag=i;
cout<<"请输入第"<cin>>goods[i].w;
cout<<"请输入第"<cin>>goods[i].p;
goods[i].p=goods[i].p/goods[i].w;//得出物品的效益,重量比
cout<}
Insertionsort(goods,n);
bag(goods,M,n);
cout<<"press <1> to run agian"<cout<<"press <0> to exit"<cin>>j;
}
}

四、实验结果:
对于0-1背包问题,贪心选择之所以不能得到最优解是因为在这种情况下,它无法保证最终
能将背包装满,部分闲置的背包空间使每公斤背包空间的价值降低了。
以上算法的时间和空间复杂度为O(n*n),其中时间复杂度基本已经不能再优化了,但空间
复杂度可以优化到O(n)。

相关文档
最新文档