实验二(贪心算法)
贪心法的编程实验
机器的最小数量k，以及当仅使用k台机器时， 所有的工作时间的最小总和。
• 输入
• 试题来源：ACM South America 2001 • 在线测试：ZOJ 1076，UVA 2387
• 随着大量的基因组DNA序列数据被获得，在这 些序列中寻找基因（基因组DNA中负责蛋白质 合成的部分）变得越来越重要。众所周知，对
于真核生物（相应于原核生物），这一过程更
为复杂，因为存在干扰基因组序列中基因编码
试题解析
• 本题要求计算FatMouse能够通过交易得到 的最大数量的Javabean。
• 首先，计算J[i]除以F[i]，结果为a[i]；然后， 对数组a按由大到小的顺序进行排序。在交 易 的 时 候 ， FatMouse 为 了 获 得 最 多 的 Javabean，要先交易a[i]大的，这样就确保 了FatMouse能获得最多的Javabean。
求解任务调度的算法步骤
• 设n项任务组成的集合T，最少用的机器台数为m； • 对n项任务开始时间升序进行排序；m=0； • while (T) { • 从T中删除当前最小开始时间的任务i；//贪心策略：
每次选择当前最小开始时间的任务 • if（任务i和已经执行的任务不冲突） • 安排任务i在空闲的机器上完成； • else { • m++; //添加一台新机器 • 任务i在新机器m上完成； •} •}
• 输出
• 对于每个测试用例，您的程序通过枚举链 中的外显子，输出一行，给出具有可能最 多的外显子的链。如果有多个链具有相同 数量的外显子，输出其中的任何一个。
贪心算法实验(求解背包问题)
算法分析与设计实验报告第四次实验
}
}
输入较小的结果：
测试结
果
输入较大的结果：
附录：
完整代码（贪心法）
;
cout<<endl;
cout<<"待装物品的价值为："<<endl;
for (i=0;i<n;i++)
cin>>item[i].v;
cout<<endl;
erval=item[i].v/item[i].w;
clock_t start,end,over; ;
实验心
得
首先这个实验，需要注意的点是背包问题与0-1背包不同，物品可以部分的放入背包中，所以思路也不一样，首先就是将物品按照单位质量价值排序，只这一点就有一点难度。
难度在于要是排序后物品的编号就会发生改变，输出的就不是之前的编号的物品，导致错误，后来发现如果为每一个物品保存一个副本，然后将它们的编号进行对比，就可以进行正确的输出了。
其中这个实验
让我学到了两点：一是结构体的使用，之前一直没有怎么用过，现在才发现自己其实不会用；二十对于库函数sort 函数的使用。
感觉每一次实验都有学到东西，很开心。
实验得
分 助教签名
sort(item,item+n,comparison); >c)
break;
tem[i]=1;
c-=item[i].w;
}
if(i<n) ;
for(i=0;i<n;i++) ==tmp[j])
x[j]=tem[i];
}
}
}。
贪心算法应用
for( i=0;i<n;i++)
cout<<setw(4)<<job[i].ID;
}
void solve(Header *head,Job*job,int n,int m)
{
int k;
for(int i=0;i<m&&i<n;i++)
{
JobNode *jobnode=new JobNode;
QuickSort(job,i,right);
}
void display(Header *M,int m)
{
JobNode *p;
for(int i=0;i<m;i++)
{
cout<<"\n第"<<i<<"台机器上处理的工作序号：";
if(M[i].next==0)
continue;
p=M[i].next;
(提示：1、把作业按加工所用的时间从大到小排序，2、如果作业数目比机器的数目少或相等，则直接把作业分配下去，3、如果作业数目比机器的数目多，则每台机器上先分配一个作业，如下的作业分配时，是选那个表头上s最小的链表加入新作业。)
# include <iostream>
# include <iomanip>
head[k].s+=jobnode->time;
while(p->next!=0)
p=p->nຫໍສະໝຸດ xt;p->next=jobnode;
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
算法分析与设计实验二贪心算法
算法分析与设计实验二贪心算法贪心算法是一种基于贪心策略的求解问题的方法，该方法在每一步都采取最优的选择，从而最终得到全局最优解。
本实验将介绍贪心算法的概念、特点以及实际应用。
1.贪心算法的概念和特点贪心算法是一种求解问题的策略，它在每一步都做出局部最优选择，以期望最终得到全局最优解。
它不考虑每一步选择的长远影响，而只关注眼前能得到的最大利益。
贪心算法有以下特点：1.1.子问题的最优解能够推导父问题的最优解：贪心算法解决的问题具有最优子结构，即问题的最优解包含其子问题的最优解。
1.2.贪心选择性质：通过选择当前最优解，可以得到局部最优解。
1.3.无后效性：当前选择的最优解不会对以后的选择产生影响。
2.实际应用2.1.背包问题背包问题是一个经典的优化问题，贪心算法可以用于解决背包问题的一种情况，分数背包问题。
在分数背包问题中，物品可以被分割成任意大小，而不仅仅是0和1两种状态，因此可以通过贪心算法求解。
2.2.最小生成树问题最小生成树问题是求解连通带权图的一种最优生成树的问题。
其中，普里姆算法和克鲁斯卡尔算法就是贪心算法的典型应用。
2.3.哈夫曼编码哈夫曼编码是一种用于对信息进行无损压缩的方法，它可以将出现频率较高的字符用较短的二进制编码表示。
贪心算法可以在构建哈夫曼树的过程中选择出现频率最低的两个字符进行合并。
3.贪心算法的设计步骤3.1.理解问题并找到最优解的子结构。
3.2.根据问题特点设计贪心策略。
3.3.利用贪心策略进行求解，并逐步推导得到全局最优解。
3.4.对求得的解进行检验，确保其满足问题的要求。
4.贪心算法的优缺点4.1.优点：贪心算法简单直观，易于实现和理解；对于一些问题，贪心算法可以得到全局最优解。
4.2.缺点：贪心算法无法保证得到问题的全局最优解；贪心策略的选择可能不唯一综上所述，贪心算法是一种基于贪心策略的求解问题的方法，通过每一步的局部最优选择，期望得到全局最优解。
贪心算法具有明显的优点和缺点，在实际应用中可以有效地解决一些问题。
贪心算法应用
edges[j].end = temp;
temp = edges[i].weight;
edges[i].weight = edges[j].weight;
edges[j].weight = temp;
}
void MiniSpanTree(MGraph *G)//生成最小生成树
for (i = 1; i <= G->arcnum; i++)//核心部分
{
n = Find(parent, edges[i].begin);
m = Find(parent, edges[i].end);
if (n != m)
{
parent[n] = m;
printf("<< %d, %d >> %d\n", edges[i].begin, edges[i].end, edges[i].weight);
{
printf("%d ",G->arc[i][j].adj);
}
printf("\n");
}
}
void sort(edge edges[],MGraph *G)//对权值进行排序
{
int i, j;
for ( i = 1; i < G->arcnum; i++)
{
for ( j = i + 1; j <= G->arcnum; j++)
}
}
}
int Find(int *parent, int f)//找尾
算法分析与设计实验二贪心算法
算法分析与设计实验二贪心算法实验二：贪心算法【实验目的】应用贪心算法求解活动安排问题。
【实验性质】验证性实验。
【实验要求】活动安排问题是可以用贪心算法有效求解的很好的例子。
问题：有n个活动的集合A={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
求解：安排尽量多项活动在该场地进行，即求A的最大相容子集。
设待安排的11个活动的开始时间和结束时间按结束时间的升序排列如下： i 1 2 35 3 06 4 57 5 38 6 59 7 6 10 8 8 11 9 8 12 10 2 13 11 12 14 s[i] 1 f[i] 4将此表数据作为实现该算法的测试数据。
【算法思想及采用的数据结构】【程序代码】【运行结果】【算法分析和心得体会】附加题：【实验要求】需要在某个城市的n个居民区之间铺设煤气管道，则在这n个居民区之间只要铺设n-1条管道即可。
假设任意两个居民区之间都可以架设管道，但由于地理环境的不同，所需经费不同。
选择最优的施工方案能使总投资尽可能少，这个问题即为求网的“最小生成树”问题。
参照以下居民区示意图，使得求解算法为：在可能架设的m条管道中选取n-1条，既能连通n-1个居民区，有使总投资达到“最小”。
网可采用邻接矩阵为存储结构，以定点对（i,j）的形式输出最小生成树的边。
D 23.1 675.9 C 41.1 56B A 38.2 441218.2 I 8.7 H 52.5 G 10.5E 98.7 居民区示意图 85F 79应用贪心算法策略，采用普里姆算法或Kruskal算法来求解居民区示意图的最小生成树，采用合适的数据结构。
用C语言或C++语言编写程序代码，选上述居民区示意图中的数据作为测试数据。
并调试输出正确结果。
【算法思想及采用的数据结构】【程序代码】【运行结果】【算法分析和心得体会】感谢您的阅读，祝您生活愉快。
《算法导论》贪心算法实验指导书（二）
《算法导论》贪心算法实验指导书（二）
《算法导论》实验指导书
本书共分阶段4个实验，每个实验有基本题和提高题。
基本题必须完成，提高题根据自己实际情况进行取舍。
题目不限定如下题目，可根据自己兴趣爱好做一些与实验内容相关的其他题目，如动态规划法中的图象压缩，回溯法中的人机对弈等。
其具体要求和步骤如下：
实验三贪心算法（4学时）
一、实验要求与目的
1、熟悉贪心算法的基本原理与适用范围。
2、使用贪心算法编程，求解最小生成树问题。
二、实验内容
1、任选一种贪心算法（Prim或Kruskal），求解最小生成树。
对算法进行描述和复杂性分析。
编程实现，并给出测试实例
一、实验要求与目的
3、熟悉贪心算法的基本原理与适用范围。
4、使用贪心算法编程，求解霍夫曼编码问题。
二、实验内容
2、采用贪心算法，求解霍夫曼编码。
对算法进行描述和复杂性分析。
编程实现，并给出测试实例
一、实验目的与要求
1、掌握汽车加油问题的算法；
2、进一步掌握贪心算法；
二、实验题
一辆汽车加满油后可以行驶N千米。
旅途中有若干个加油站。
若要使沿途的加油次数最少，设计一个有效的算法，指出应在那些加油站停靠加油。
并证明你的算法能产生一个最优解。
三、实验提示
把两加油站的距离放在数组中，a[1..n]表示从起始位置开始跑，经过n个加油站，a[k]表示第k－1个加油站到第k个加油站的距离。
汽车在运行的过程中如果能跑到下一个站则不加油，否则要加油。
（算法略）。
集合覆盖模型实验报告
一、实验目的1. 理解集合覆盖问题的基本概念和模型。
2. 掌握贪心算法在集合覆盖问题中的应用。
3. 分析不同算法在解决集合覆盖问题时的效率和效果。
二、实验内容1. 实验背景集合覆盖问题是一种经典的组合优化问题，其目标是找到一个子集的集合，使得这些子集的并集覆盖了给定的全集，并且子集的个数最少。
在现实生活中，集合覆盖问题广泛应用于资源分配、广告覆盖、网络设计等领域。
2. 实验环境- 操作系统：Windows 10- 编程语言：Python 3.8- 库：numpy，networkx3. 实验步骤（1）构建实验数据本实验中，我们使用以下数据集：- 全集U = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}- 子集集合S = {S1 = {1, 2, 3}, S2 = {3, 4, 5}, S3 = {5, 6, 7}, S4 = {7, 8, 9}, S5 = {9, 10}}（2）实现贪心算法根据贪心算法的思想，我们设计以下步骤：1. 初始化结果集合为空。
2. 遍历所有子集，找到覆盖未覆盖元素最多的子集，将其加入结果集合。
3. 从全集U中去除被覆盖的元素。
4. 重复步骤2和3，直到全集U为空。
（3）实验结果分析我们使用贪心算法对上述数据集进行求解，得到最优解为{S1, S2, S3}，覆盖了全集U。
4. 对比其他算法为了对比贪心算法的效率，我们使用穷举法进行求解。
穷举法将所有可能的子集组合进行遍历，找出覆盖全集的最小子集集合。
在本实验中，穷举法需要遍历C(5,2) + C(5,3) + C(5,4) + C(5,5) = 70种组合，效率较低。
三、实验结论1. 贪心算法可以有效地解决集合覆盖问题，并且在某些情况下可以得到最优解。
2. 与穷举法相比，贪心算法具有更高的效率，尤其是在数据规模较大时。
3. 集合覆盖问题在实际应用中具有重要意义，可以用于解决资源分配、广告覆盖、网络设计等问题。
实验二 贪心算法
实验二贪心法（4学时）上机实验一般应包括以下几个步骤：（1）、准备好上机所需的程序。
手编程序应书写整齐，并经人工检查无误后才能上机。
（2）、上机输入和调试自己所编的程序。
一人一组，独立上机调试，上机时出现的问题，最好独立解决。
（3）、上机结束后，整理出实验报告。
实验报告应包括：题目、程序清单、运行结果、对运行情况所作的分析。
一、实验目的与要求1.掌握贪心法的基本思想方法；2.了解适用于用贪心法求解的问题类型，并能设计相应贪心法算法；3.掌握贪心算法复杂性分析方法分析问题复杂性。
二、实验内容：1、哈夫曼编码设需要编码的字符集为{d1, d2, …, dn}，它们出现的频率为{w1, w2, …, wn}，应用哈夫曼树构造最短的不等长编码方案。
设计贪心算法求解此哈夫曼编码方案；2、删数问题键盘输入一个高精度的正整数n（n<10位）去掉任意s个数字后剩下的数字按原左右次序组成一个新的正整数。
编程对给定的n和s，寻找一种方案，使得剩下的数最小。
3、贪心背包问题已知一个容量为M的包和n件物品, 每件物品的重量为w i, 效益值为p i. 若将物品i的一部分0≤x i≤1装入包中, 背包可得到p i x i的效益值增量. 要求找到一种装入物品的方案, 在不超过包的总容量前提下, 使包获得最大效益值。
三、实验步骤1．理解算法思想和问题要求；2．编程实现题目要求；3．上机输入和调试自己所编的程序；4．验证分析实验结果；5．整理出实验报告。
四、实验要求1）上述题目任选两道做。
2）独立完成程序代码的编写3）独立完成实验及实验报告附：实验报告的主要内容一．实验目的二．问题描述三．解题思路四．算法设计包含：数据结构与核心算法的设计描述、函数调用及主函数设计、主要算法流程图等五.程序调试及运行结果分析六.实验总结附录：程序清单（程序过长，只附主要部分）五、实验原理贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。
贪心算法-找零问题 实验报告
实验三课程名称：算法设计与实现实验名称：贪心算法-找零问题实验日期：2019年5月2日仪器编号：007班级：数媒0000班姓名：郝仁学号0000000000实验内容假设零钱系统的币值是{1，p,p^2,……，p^n},p>1,且每个钱币的重量都等于1，设计一个最坏情况下时间复杂度最低的算法，使得对任何钱数y，该算法得到的零钱个数最少，说明算法的主要设计思想，证明它的正确性，并给出最坏情况下的时间复杂度。
实验分析引理1（离散数学其及应用3.1.4）：若n是正整数，则用25美分、10美分、5美分和1美分等尽可能少的硬币找出的n美分零钱中，至多有2个10美分、至多有1个5美分、至多有4个1美分硬币，而不能有2个10美分和1个5美分硬币。
用10美分、5美分和1美分硬币找出的零钱不能超过24美分。
证明如果有超过规定数目的各种类型的硬币，就可以用等值的数目更少的硬币来替换。
注意，如果有3个10美分硬币，就可以换成1个25美分和1个5美分硬币；如果有2个5美分硬币，就可以换成1个10美分硬币；如果有5个1美分硬币，就可以换成1个5美分硬币；如果有2个10美分和1个5美分硬币，就可以换成1个25美分硬币。
由于至多可以有2个10美分、1个5美分和4个1美分硬币，而不能有2个10美分和1个5美分硬币，所以当用尽可能少的硬币找n美分零钱时，24美分就是用10美分、5美分和1美分硬币能找出的最大值。
假设存在正整数n，使得有办法将25美分、10美分、5美分和1美分硬币用少于贪心算法所求出的硬币去找n美分零钱。
首先注意，在这种找n美分零钱的最优方式中使用25美分硬币的个数q′，一定等于贪心算法所用25美分硬币的个数。
为说明这一点，注意贪心算法使用尽可能多的25美分硬币，所以q′≤q。
但是q′也不能小于q。
假如q′小于q，需要在这种最优方式中用10美分、5美分和1美分硬币至少找出25美分零钱。
而根据引理1，这是不可能的。
贪心算法实验报告(C语言)
实验2、《贪心算法实验》一、实验目的1. 了解贪心算法思想2. 掌握贪心法典型问题，如背包问题、作业调度问题等。
二、实验内容1. 编写一个简单的程序，实现单源最短路径问题。
2. 编写一段程序，实现找零。
【问题描述】当前有面值分别为2角5分，1角，5分，1分的硬币，请给出找n分钱的最佳方案（要求找出的硬币数目最少）。
3. 编写程序实现多机调度问题【问题描述】要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m 台机器加工处理完成。
约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
三、算法思想分析1.初始化将源点设计为红点集，其余点设计为蓝点，重复选择蓝点集中与源点路径最短的点加入红点集，更新剩余的蓝点集路径，直至蓝点集为空或者只剩下没有连通的点，那么源点到其余所有点的最短路径就出来了。
2.找零问题是典型的贪心问题，但是并不代表所有的找零都能用贪心算法找到最优解。
只有满足贪心选择性质的找零才能找到最优解，本题满足贪心选择性质，直接先一直选面值最大的硬币，再一次减小即可。
3.先对作业按时长进行重排序，再依次找目前用时最短的机器安排工作并加上对应时长，最后总时长为机器中用时最长的那个时长。
四、实验过程分析1.单源最短路径的算法思想并不难，但是在实际编码过程中还是有很多小问题需要注意，首先，一定要新建数组存储路径变化，因为后面计算路径时会用到原数组，如果直接在原数组上更改后面就找不到原数据了，那么就会出现偏差。
其次就是建议先写个伪代码，判断的if-else语句比较多，容易搞混，在代码中一定要及时备注，某些代码的功能是什么，不然再次看代码时需要思考很久甚至忘记。
2.找零问题直接用while循环或者不断取余取模即可解决。
3.作业调度问题大致分为三步，一是排序，二是不断找最短时长的机器安排作业，三是找最长时间为作业完成时间。
五、算法源代码及用户屏幕1.（1）算法源码/**********************单源最短路径问题。
实验二(贪心算法)
华东师范大学计算机科学技术系上机实践报告课程名称：算法设计与分析年级：05上机实践成绩：指导教师：柳银萍姓名：张翡翡上机实践名称：贪心算法学号：10052130119上机实践日期：2007-4-10上机实践编号：NO.2组号：上机实践时间：10:00-11:30一、目的了解熟悉掌握贪心算法实质并学会灵活运用，从而解决生活中一些实际问题。
二、内容与设计思想1.超市的自动柜员机(POS)要找给顾客各种数值的现金，表面上看，这是一个很简单的任务，但交给机器办就不简单了。
你作为一个计算机专家，要求写一个程序来对付这个“简单”的问题。
你的自动柜员机有以下的币种：100元，50元，20元，10元，5元，2元，1元。
你可以假设每种钱币的数量是无限的。
现在有一笔交易，需要找个客户m元，请你设计一个算法，使得找给顾客的钱币张数最少。
要求：输入：第一行仅有一个整数n(0<n<=10000),表示有几组测试数据。
每组测试数据仅有一行，每行只有一个整数m(0<m<2000000000)，表示需要找的钱币数。
(提示：对于大量的输出，请使用scanf,不要使用cin)输出：每组测试数据输出一行，每行有7个整数(两两之间有一个空格，结尾不能有空格)，表示100元，50元，20元，10元，5元，2元，1元所需要的张数。
1.1其思路是：1)定义相关变量；2)接收相关数据，如测试数据组数n和要找的钱币数；3)依次考虑100，50，20，10，5，2，1的需要找的钱币张数，用最简单的加减乘除；4)输出其值。
1.2具体算法是：while(n--)m 输入a=m/100b=(m-100*a)/50c=(m-100a-50b)/20d=(m-100a-50b-20c)/10e=(m-100a-50b-20c-10d)/5f=(m-100a-50b-20c-10d-5e)/2g=m-100a-50b-20c-10d-5e-2fend while2.若在0-1背包问题中各物品是依重量递增排列时，其价值恰好依递减序排列。
贪心算法实验python
南阳理工学院算法设计与分析报告册开课学院：计算机与信息工程学院实验项目：贪心算法实验实验时间：实验地点：指导教师：学生姓名：学生学号：专业班级： 18大数据2019-2020学年第2学期一、实验目的1.了解贪心算法思想及基本原理2.掌握使用贪心算法求解问题的一般特征3.能够针对实际问题，能够正确选择贪心策略。
4.能够针对选择的贪心策略，证明算法的正确性。
5.能够根据贪心策略，正确编码。
6.能够正确分析算法的时间复杂度和空间复杂度二、实验平台1.Windows操作系统或Linux操作系统2.Python3.x3.pyCharm或sublime或jupyter notebook三、实验内容最优服务次序问题：设有n个顾客同时等待一项服务。
顾客i需要的服务时间为ti,1≤i≤n。
共有s处可以提供此服务。
应如何安排n个顾客的服务次序才能使平均等待时间达到最小平均等待时间是n个顾客等待服务时间的总和除以n。
四、算法设计1.问题分析根据贪心思想，哪位顾客服务所需的时间短，就先服务那个顾客，然后依次类推，每次都是首先服务所需时间短的，这样能保证等待时间最短。
2.问题建模输入;集合s={1,2,3,...,n},第i个顾客的服务时间；输出：第i个顾客的等待时间目标函数：SUM(每个顾客的等待时间）/总顾客的数，得到平均等待时间3.算法描述首先保存每位顾客的服务时间到数组，然后把服务时间使用冒泡排序按照从小到大排序，然后遍历数组，服务时间最小的先服务，然后其次被服务的顾客的等待时间为（上一位顾客的服务时间和自己的被服务时间）最后求出总的服务时间在除以总顾客数得到最小平均等待时间。
五、算法源码def waitime(n):a=[0 for i in range(0,n)]#定义一个数组并将n个服务时间存进数组a for i in range(0,len(a)):a[i]=int(input(("请输入顾客需要的服务时间:")))for i in range(0, len(a) - 1): # 冒泡排序，将这n个服务时间从小到大排序for j in range(0, len(a) - i - 1):if (a[j] > a[j + 1]):a[j], a[j + 1] = a[j + 1], a[j]sum=a[0]#排完序后第一个最先开始for i in range(1,len(a)):a[i]=a[i]+a[i-1]sum=sum+a[i]time=sum/n#求出最小平均等待时间print("最小平均等待时间是：",time)if __name__ == "__main__":n=int(input(("请输入顾客个数：")))waitime(n)六、测试数据请输入顾客个数：4分别为：2 3 5 1最小平均等待时间是： 5.25七、程序运行结果（要求：截图说明算法运行的结果）八、算法分析（分析算法的时间复杂度和空间复杂度）时间复杂度：程序进行了一次排序（O(nlogn)）和循环（O(n)），故时间复杂度为O(nlogn)；空间复杂度：程序定义了一个一维数组（lengh_n[n]）用于存放每个程序的大小，故时间复杂度为O(n)。
实验二贪心算法
一、实验目的
1. 运用背包问题解决具体问题 2. 培养编程与上机调试能力
程序实现
完成程序的编程和调试，输出正确结果 （仅供参考）
实例
实例
三、实验原理
贪心算法是指，在对问题求解时，总是做出在当前看 来是最好的选择，不从整体最优上加以考虑，所做出 的仅是在某种意义上的局部最优解。 贪心算法(Greedy algorithm)是一种对某些求最优解 问题的更简单、更迅速的设计技术。它采用自顶向下, 以迭代的方法做出相继的贪心选择，每做一次贪心选 择就将所求问题简化为一个规模更小的子问题 , 通过 每一步贪心选择，可得到问题的一个最优解，虽然每 一步上都要保证能获得局部最优解，但由此产生的全 局解有时不一定是最优的，所以贪婪法不要回溯。
二、实验内容
实现背包问题的贪心算法 己知一个容量为M的背包。现在要从n种物品中选 取若干装入背包中，每种物品的重量为w(i) 、价 值为p(i) 。定义一种可行的背包装载为：背包中物 品的总重量不能超过背包的容量，每种物品仅有 一件，可以选择放或不放。采取怎样的装包方案 才会使装入背包的物品价值总和最大? 考虑：如果物品可分割，算法如何实现（选做）。
有解元素组合成问题的一个可行解。
该算法存在问题： 1、不能保证求得的最后解是最佳的； 2、不能用来求最大或最小解问题； 3、只能求满足某些约束条件的可行解的范围。
四、实验步骤
1、设计算法； 2、采用高级语言实现该算法； 3、调试程序，检查输出结果。
算法分析与设计实验二贪心算法
算法分析与设计实验二贪心算法贪心算法（Greedy Algorithm）是一种常用的算法设计方法，其核心思想是在每一步都做出当前情况下最优选择，以期望最终得到全局最优解。
本实验主要介绍贪心算法的原理、应用和分析。
一、贪心算法的原理贪心算法的基本思路是在每一步都做出当前情况下最优选择，并且不考虑当前选择对后续选择的影响。
贪心算法通常采用贪心选择策略和最优子结构两个基本要素。
1.贪心选择策略贪心选择策略是指在每一步都选择当前情况下最优解的策略。
这种策略要求我们能够证明，通过选择当前最优解，可以使得问题的规模减小到原问题的一个子问题，并且该子问题的最优解一定包含在全局最优解中。
2.最优子结构最优子结构是指问题的最优解包含其子问题的最优解。
贪心算法求解问题的过程通常包括两个步骤，选择最优子结构和利用最优子结构得到最优解。
二、贪心算法的应用1.集合覆盖问题集合覆盖问题是指在给定的一组集合中，找出最小的子集合，使得这些子集合的并集包含所有的元素。
贪心算法可以通过每一步选择包含最多未覆盖元素的集合，直到覆盖所有元素为止。
2.挑选活动问题挑选活动问题是指在给定一组活动的起始时间和结束时间，找出最大的相容活动子集合。
贪心算法可以通过每一步选择结束时间最早的活动，之后将该活动与其他相容的活动进行比较，从而得到最大的相容活动子集合。
3.分数背包问题分数背包问题是指在给定一组物品和一个背包容量的情况下，选择部分物品放入背包，使得放入背包的物品总价值最大。
贪心算法可以通过每一步选择单位重量价值最高的物品，直到背包容量不足为止。
三、贪心算法的分析贪心算法通常具有高效性和近似最优性的特点。
由于贪心算法每一步都选择当前最优解，不进行回溯和剪枝的操作，因此贪心算法的时间复杂度较低。
然而，贪心算法并不总能得到问题的最优解，它通常只能得到近似最优解。
贪心算法的近似性证明可以分为两步。
首先，我们需要证明贪心选择策略的正确性，即每一步选择的最优解一定包含在全局最优解中。
贪心算法实现背包问题算法设计与分析实验报告
算法设计与分析实验报告实验名称贪心算法实现背包问题评分实验日期年月日指导教师姓名专业班级学号一.实验要求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、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
华东师范大学计算机科学技术系上机实践报告课程名称：算法设计与分析年级：05上机实践成绩：指导教师：柳银萍姓名：张翡翡上机实践名称：贪心算法学号：10052130119上机实践日期：2007-4-10上机实践编号：NO.2组号：上机实践时间：10:00-11:30一、目的了解熟悉掌握贪心算法实质并学会灵活运用，从而解决生活中一些实际问题。
二、内容与设计思想1.超市的自动柜员机(POS)要找给顾客各种数值的现金，表面上看，这是一个很简单的任务，但交给机器办就不简单了。
你作为一个计算机专家，要求写一个程序来对付这个“简单”的问题。
你的自动柜员机有以下的币种：100元，50元，20元，10元，5元，2元，1元。
你可以假设每种钱币的数量是无限的。
现在有一笔交易，需要找个客户m元，请你设计一个算法，使得找给顾客的钱币张数最少。
要求：输入：第一行仅有一个整数n(0<n<=10000),表示有几组测试数据。
每组测试数据仅有一行，每行只有一个整数m(0<m<2000000000)，表示需要找的钱币数。
(提示：对于大量的输出，请使用scanf,不要使用cin)输出：每组测试数据输出一行，每行有7个整数(两两之间有一个空格，结尾不能有空格)，表示100元，50元，20元，10元，5元，2元，1元所需要的张数。
1.1其思路是：1)定义相关变量；2)接收相关数据，如测试数据组数n和要找的钱币数；3)依次考虑100，50，20，10，5，2，1的需要找的钱币张数，用最简单的加减乘除；4)输出其值。
1.2具体算法是：while(n--)m 输入a=m/100b=(m-100*a)/50c=(m-100a-50b)/20d=(m-100a-50b-20c)/10e=(m-100a-50b-20c-10d)/5f=(m-100a-50b-20c-10d-5e)/2g=m-100a-50b-20c-10d-5e-2fend while2.若在0-1背包问题中各物品是依重量递增排列时，其价值恰好依递减序排列。
对这个特殊的0-1背包问题，请设计一个有效算法找出最优解，并证明算法的正确性。
要求：输入：输入只有四行，第一行有一个正数n（n <= 10000）为物品的数量。
第二行有n 个递增的整数表示每一个物品的重量。
第三行有n个递减的整数，表示每个物品的价值。
最后一行有一个整数w表示背包的容量。
所有数据均小于1000000。
输出：输出背包可带走物品的最大价值。
2.1其思路是：1)定义相关变量及赋初值；2)接收相关数据如物品的数量，每个物品的重量及每个物品的价值，以及背包的容量；3)写两个排序函数，一个递增一个递减；4)用一个循环判断装进的重量是否超过背包容量；5)最后输出所装下的容量大小。
2.2具体算法是：n←输入for i ←0 to na[i]←输入for i←0 to nb[i]←输入w←输入k←ifor i←0 to nfor j←i+1 to nif a[k]>a[j] then k=jt=a[i]a[i]=a[k]a[k]=tk←ifor i←0 to nfor j←i+1 to nif b[k]<b[j] then k=jt=b[i]b[i]=b[k]b[k]=tfor i←0 to nmax+=a[i]if max<=w thensum+=b[i]return(0)2.3算法的正确性证明：3．一辆汽车加满油后可行驶n公里。
旅途中有若干个加油站。
设计一个有效算法，指出应在哪些加油站停靠加油，使沿途加油次数最少。
对于给定的n(n <= 5000)和k(k <= 1000)个加油站位置，编程计算最少加油次数。
要求：输入：第一行有2个正整数n和k，表示汽车加满油后可行驶n公里，且旅途中有k个加油站。
接下来的1 行中，有k+1 个整数，表示第k个加油站与第k-1 个加油站之间的距离。
第0 个加油站表示出发地，汽车已加满油。
第k+1 个加油站表示目的地。
输出：输出编程计算出的最少加油次数。
如果无法到达目的地，则输出”NoSolution”。
3.1其思路是：1)定义相关变量及赋初值；2)接收相关数据如加满油能行驶的距离，加油站个数和各加油站之间的距离；3)考虑特殊情况：(1)如果起点到第一个加油站距离大于加满油时能行驶距离，则输出“No Solution!”(2)如果七次加满油和起始站加满油之和能行驶距离小于起点到终点距离，则输出“NoSolution”4)for循环处理各个站情况，如果剩余的油能行驶的距离大于到下一个站的距离，则不用再加油，如果剩余的油能行驶的距离小于到下一个站的距离，则加满油，如果加满油还是小于则输出“No Solution”，否则使计数m加一；5)最后输出m的值。
3.2具体算法是：n←输入k←输入for i←0 to ka[i]←输入sum+=a[i]if n<a[0] then printf(No Solution!)else if n*(k+1)<sum then printf(No Solution!)elseleft=n-a[0]for i←1 to kif left>a[i] then left-=a[i]elset=n+leftif t<a[i] then printf(No Solution!)elseleft=t-a[i]m+=1printf(m)return(0)三、使用环境Microsoft visual C++ 6.0四、调试过程1.有时候太大意，第一次调试时居然忘了打“*”符号，导致出现一大堆错误，我用的是最笨的办法来算钱币数，其实知道还有更优的方法去解决，之后还可以再研究研究，还出现一个问题就是粗心，“/”号打成“%”号导致结果错误甚至出现一堆乱码类东西。
2.做第二个程序基本没什么大问题，只是刚开始的时候排序函数没有单独写出来导致测试不正确，还有一开始没有在main()函数中定义调用的两个排序函数，最粗心的是将两个函数相反了一下，即把重量按升序排，价值按减序排导致结果很离谱。
还有一个问题是最后一个for语句判断重量有没有超过背包总重量时只是加出来总重量，即在b[i]的地方写成了a[i]，不过好在都是小错误。
3.第三个程序很顺利，只是在审题的时候考虑地太过复杂，考虑了比如现在第一个站它能开到第二个站，但是第二个站到第三个站即使加满油也不能开到的时候，我再考虑是不是该在第一个站加上油这样就能够从第二站到第三站，问题就变得复杂多了。
调试过程只有一个地方出现问题就是考虑了剩余油能行驶距离如果小于接下来要行驶的距离，而忘了处理如果剩余油大于接下来能行驶距离情况下的left的值的改变。
经过一步一步调试而处理好。
五、总结基础虽然简单但有时候还是要掌握牢固才好，粗心有时候会耽误很多不必要的时间要尽量克服，在写程序的时候认真才行。
有时候还是不能偷懒，要尽量想想其他更优的方法，比如第一个程序我用的就是最笨最原始的方法，很显然复杂度可能就大了。
基础不扎实，在调用函数的时候在开头没有定义，不过经同学指点就可以改，应该学会更深一层思考以及用多种不同的方法实现，比如排序方法有很多种，可以借此机会多思考采用各种排序方法，从而巩固了以前的知识。
考虑问题要全面，虽然有时候会将问题复杂化但是至少思考过程能学到很多东西，这样会使逻辑越来越严谨。
六、附录1. 找零钱问题的程序：（此处放程序）#include<stdio.h>int main(){int a,b,c,d,e,f,g,n,m;scanf("%d",&n);while(n--){scanf("%d",&m);a=m/100;b=(m-100*a)/50;c=(m-100*a-50*b)/20;d=(m-100*a-50*b-20*c)/10;e=(m-100*a-50*b-20*c-10*d)/5;f=(m-100*a-50*b-20*c-10*d-5*e)/2;g=m-100*a-50*b-20*c-10*d-5*e-2*f;printf("%d %d %d %d %d %d %d\n",a,b,c,d,e,f,g);}return(0);}运行结果：2. 0-1背包问题的程序：（此处放程序）#include<stdio.h>int main(){void sort1(int a[10000],int n);void sort2(int b[10000],int n);int a[10000],b[10000];int w,i,n;int max=0;int sum=0;scanf("%d",&n);for(i=0;i<n;i++)scanf("%d",&a[i]);for(i=0;i<n;i++)scanf("%d",&b[i]);scanf("%d",&w);sort1(a,n);sort2(b,n);for(i=0;i<n;i++){max+=a[i];if(max<=w)sum+=b[i];}printf("%d\n",sum);return(0);}void sort1(int a[10000],int n){int i,j,k;int t;for(i=0;i<n;i++){k=i;for(j=i+1;j<n;j++)if(a[k]>a[j])k=j;t=a[i];a[i]=a[k];a[k]=t;}}void sort2(int b[10000],int n){int i,j,k;int t;for(i=0;i<n;i++){k=i;for(j=i+1;j<n;j++)if(b[k]<b[j])k=j;t=b[i];b[i]=b[k];b[k]=t;}}运行结果:3．汽车加油问题的程序：（此处放程序）#include<stdio.h>int main(){int n,k,i,left;int a[1025];int sum=0;int m=0;int t=0;scanf("%d",&n);scanf("%d",&k);for(i=0;i<=k;i++){scanf("%d",&a[i]);sum+=a[i];}if(n<a[0])printf("No Solution!");elseif(n*(k+1)<sum)printf("No Solution!");else{left=n-a[0];for(i=1;i<=k;i++){if(left>a[i])left-=a[i];elseif(left<=a[i]){t=n+left;if(t<a[i])printf("No Solution!");elseleft=t-a[i];m+=1;}}printf("%d\n",m);}return(0);}运行结果:要求至少给出1组测试数据运行结果。