课程设计报告-贪心算法:任务调度问题
贪心法解活动安排问题(计算机算法设计与分析)
实验报告
课程名称:算法设计与分析实验名称:贪心法解活动安排问题任课教师:专业:计算机科学与技术
班级: 20xx 级x班学号:
姓名:完成日期: 20xx年x月xx日
五、实验总结
在做本实验之前,自己看了课本上所列举的贪心法解活动安排问题的代码,代码很简单,很容易理解,于是就按课本的代码实现。
通过几个测试用例测试发现结果不对,后来发现自己忘了进行贪心法的一个前提条件,事先没有按各个活动结束时间对所有活动进行非递减排序,所以才会导致结果错误。
经过修正后,自己真正理解了贪心法解活动安排问题的原理,重新完成本次实验内容也是很顺利,在编程方面没有遇到什么困难。
算法分析与设计-实验四 作业调度问题-实验报告
南阳理工学院算法分析与设计实验报告册开课学院:计算机与软件学院实验项目:实验4:贪心法(作业调度问题)实验时间:第10周周3(3,4)节实验地点: 15#515指导教师:学生姓名:学生学号:专业班级:2020-2021学年第1学期一、实验目的1.了解贪心算法思想及基本原理2.掌握使用贪心算法求解问题的一般特征3.能够针对实际问题,能够正确选择贪心策略4.能够针对选择的贪心策略,证明算法的正确性5.能够根据贪心策略,正确编码6.能够正确分析算法的时间复杂度和空间复杂度二、实验平台1.JDK1.82.IDEA三、实验内容设有n个独立的作业{1, 2, …,n},由m台相同的机器{M1, M2, …,Mm}进行加工处理,作业i所需的处理时间为ti (1≤i≤n),每个作业均可在任何一台机器上加工处理,但不可间断、拆分。
多机调度问题要求给出一种作业调度方案,使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
提示:贪心法求解多机调度问题的贪心策略是最长处理时间作业优先,即把处理时间最长的作业分配给最先空闲的机器,这样可以保证处理时间长的作业优先处理,从而在整体上获得尽可能短的处理时间。
按照最长处理时间作业优先的贪心策略,当m≥n时,只要将机器i的[0, ti)时间区间分配给作业i即可;当m<n时,首先将n 个作业依其所需的处理时间从大到小排序,然后依此顺序将作业分配给空闲的处理机。
四、算法设计1.问题分析设有n个独立的作业{1, 2, …, n}, 由m台相同的机器进行加工处理. 作业i所需时间为t i. 约定:任何作业可以在任何一台机器上加工处理, 但未完工前不允许中断处理,任何作业不能拆分成更小的子作业。
要求给出一种作业调度方案,使所给的n 个作业在尽可能短的时间内由m台机器加工处理完成。
多机调度问题是一个NP完全问题,到目前为止还没有完全有效的解法。
对于这类问题,用贪心选择策略有时可以设计出一个比较好的近似算法。
贪心算法实验报告算法实验贪心法实验报告
贪心算法实验报告算法实验贪心法实验报告西安邮电大学(计算机学院)课内实验报告实验名称:贪心算法专业名称:班级:学生姓名:学号(8指导教师:实验日期:一. 实验目的及实验环境1.练习掌握最有分解问题的规划设计与实现;2.熟练掌握递归算法的设计及应用,怎样才能使算法的空间复杂度和时间复杂度最低;基于Linux系统下的ubuntu或其他的编辑器二. 实验内容1. 设n是一个正整数,现在要求将n分解为若干互不相同的自然数的和,且使这些自然数的乘积最大三.方案设计1.先将这个数分解成以2开始的连续的若干因子,它们的和加起来是n,将此数在后项优先的方式下均匀地分给前面各项。
保证正整数所分解出的因子之差的绝对值最小,即| a – b |最小,可以保证分解乘积越大。
四.测试数据及运行结果1.正常测试数据(3组)及运行结果;A.2.非正常测试数据(2组)及运行结果A.B.五.总结1.实验过程中遇到的问题及解决办法;在实验过程中错误不断地出现,我认真地查阅书籍,研究课本上例题,并且在同学的帮助下纠正了自己的错误,得出了正确的结果。
2.对设计及调试过程的心得体会。
在程序的运行与调试过程中出现了很多错误,但是通过自己复习课本知识、查询资料等,修改后得出了正确的结果。
而且我觉得自己一定要敢于尝试,即使没有结果但是勇于实践就会有意想不到的收获。
所以在以后的学习中我觉得我们一定要集中精力、端正自己态度,提高自己的成绩。
当然我也认识到了自己的薄弱之处,因此我一定争取做的能让自己满意,做的更好。
六.附录:源代码(电子版)#include#includevoid open_file(int n){FILE *fp;if((fp=fopen(“input.txt”,”wt”))==NULL) {printf(“the file write failed.\n”);exit(1);}fprintf(fp,”%2d\n”,n);fclose(fp);}void save_file(int sum){FILE *fp;if((f p=fopen(“output.txt”,”wt”))==NULL) {printf(“ the file save failed!.\n”);exit(1);}fprintf(fp,”%2d\n”,sum);fclose(fp);if((fp=fopen(“output.txt”,”r”))==NULL) {printf(“save file failed!\n”);exit(1);}fscanf(fp,”%2d”,&sum);printf(“\n鏈€澶х?d\n”,sum);fclose(fp);}int MAX(int n){int i=2,j=0,data[n],sum=0,max=1; int lenth; while(sum+i{sum+=i;data[j]=i;i++;j++;}lenth=j;i=n-sum;while(i>0){if(j{data[j+i]+=1;i--;j--;}else{data[j-1]+=1;i--;j--;}}for(i=0;imax*=data[i];return max;}int main(){int n,max;srand((unsigned)time(NULL)); n=rand()%100; open_file(n);printf(“ 杩欎釜鏁版槸%d:\n”,n); max=MAX(n); save_file(max);return 0; }百度搜索“就爱阅读”,专业资料,生活学习,尽在就爱阅读网,您的在线图书馆。
贪心算法在任务调度中的应用
贪心算法在任务调度中的应用在任务调度中,选择最优的方案是一个核心问题。
贪心算法是一种运用广泛的解决最优问题的算法,其优势在于可以处理高效率、可扩展性、可贪心性等众多特性。
然而,在实际应用中,贪心算法也需要根据不同场景进行不同的调整。
本文将探讨贪心算法在任务调度中的应用,包括背包问题、最小生成树问题和区间调度问题等。
一、背包问题背包问题是一个经典的优化问题,其核心是如何选择一组物品,使得总重量不超过背包能够容纳的最大值,同时价值最大化。
在任务调度中,背包问题可以被用来解决资源分配问题,例如在云计算中,如何合理地分配虚拟机来保证服务质量和节约资源。
贪心策略是按照每个物品的单位价值来进行排序,优先选择单位价值高的物品先放入背包中。
这样可以使得背包中的物品价值最大化,同时满足容量限制。
具体实现中,可以在排序后从价值最高的物品开始放入背包,直到背包无法容纳为止。
但是在实际应用中,贪心算法并不一定能够获得最优解。
在一些场景中,例如物品具有相同的价值,需要根据其他因素进行调整。
此外,在背包容量限制较小的情况下,贪心策略也可能会导致不优的解。
二、最小生成树问题最小生成树问题是一个经典的图论问题,其核心是从一个无向图中寻找一棵生成树,使得树上所有边的权值之和最小。
在任务调度中,最小生成树问题可以被用来解决任务分配问题,例如如何合理地分配人力资源来保证任务的顺利完成。
贪心策略是按照边的权值进行排序,优先选择权值最小的边来进行连接。
在每个节点中维护一个集合,表示当前节点所在的连通块。
在选择一条边之后,可以将两个连通块进行合并,直到所有节点被连接为止。
但是在实际应用中,最小生成树问题也需要根据具体情况进行调整。
例如在一些特殊场景中,例如图中存在负权边时,需要使用其他算法来处理;在连通块的个数较多时,贪心策略也可能会导致无法得到最优解。
三、区间调度问题区间调度问题是一个经典的贪心问题,其核心是找到最大的相容区间数量。
在任务调度中,区间调度问题可以被用来解决场馆安排、空间分配等问题。
贪心算法设计实验报告
A
B
C
D
E
F
G
0
0
0
0
1
0
0
0
对表进行维护(维护后仍同上表,因为还没有两个集合合并)
0
A
B
C
D
E
F
G
0
0
0
0
1
0
0
0
C,选择第二条边 C----E (修改上表)
0
A
B
C
D
E
F
G
0
0
0
0
1
3
0
0
对上表进行维护(任同上表,因为还没有两个集合合并)
0
A
B
C
D
E
F
G
0
0
0
0
1
3
0
0
D,选择第三条边( D-----F ) (根据条件 DF 两点不再同一集合,改边可选 ) 然后就合并 DF 两点所在的集合 D 的前去是 1,即 A 标记为 0, E 的标记也为 0,合并因为 6>1 所以表修改如下
Edge* selectionsort(Edge *array,int n)// 选择排序(对边按权重由高到低排序) {
int i,j,min,temp; for(i=0;i<n;i++) {
min=i; for(j=i+1;j<n;j++)
if(array[min].weight>array[j].weight) min=j;
在同一棵树上,则不可取,而应该取下一条权值最小的边再试之。依次类推,直至森林中
只有一棵树,也即子图中含有
贪心算法解决活动安排问题报告
1.引言:贪心法是一种改进了的分级处理方法。
用贪心法设计算法的特点是一步一步地进行,每一步上都要保证能获得局部最优解。
每一步只考虑一个数据,它的选取满足局部优化条件。
若下一个数据与部分最优解连在一起不再是可行解时,就不把该数据添加到部分解中,直到把所有数据枚举完,或者不能再添加为止。
这种能够得到某种度量意义下的最优解的分级处理方法称为贪心法。
贪心算法总是做出在当前看来是最优的选择,也就是说贪心算法并不是从整体上加以考虑,它所做出的选择只是在某种意义上的局部最优解,而许多问题自身的特性决定了该题运用贪心算法可以得到最优解或较优解。
2.贪心算法的基本思想及存在问题贪心法的基本思想:从问题的某一个初始解出发逐步逼近给定的目标,以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时,算法停止。
1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解,得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。
3.活动安排问题:3.1 贪心算法解决活动安排问题学校举办活动的安排问题是用贪心算法有效求解的一个很好例子。
活动安排问题要求安排一系列争用某一公共资源的活动。
用贪心算法可使尽可能多的活动能兼容的使用公共资源。
设有n个活动的集合{0,1,2,…,n-1},其中每个活动都要求使用同一资源,如会场等,而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间starti和一个结束时间endi,且starti<endi。
如选择了活动i,则它在半开时间区间[starti,endi)内占用资源。
若区间[starti,endi)与区间[startj,endj)不相交,称活动i与活动j是相容的。
也就是说,当start j≥endi或starti≥endj时,活动i与活动j相容。
活动安排问题就是在所给的活动集合中选出最大的相容子活动集合。
贪心算法实验报告
typedef struct node{
int id ,time;//作业所需时间
}jobnode;
typedef struct Node{
int id ,avail;//id机器编号、avail每次作业的初始时间
}manode;
manode machine[N];
jobnode job[N];
scanf("%d",&n);
printf("请输入加油站的个数:");
scanf("%d",&k);
for(i=0;i<=k;i++)
scanf("%d",&d[i]);
greedy(d,n,k);
}
实验结果截图:
(3)实验代码:设有n个正整数,将它们连接成一排,组成一个最大的多位整数
#include<stdio.h>
return;
}
}
for(i=0,s=0;i<=k;i++){
if(s<n)
s+=d[i];
else if(s>n){
n=s-d[i];
num++;
}
}
printf("%d\n",num);
}
void main(){
int i,n,k;
int d[1000];
printf("请输入汽车可行驶公里数:");
/*找出下一个作业执行机器*/
manode *Find_min(manode a[],int m){
manode *temp=&a[0];
贪心算法实验报告
一、实验目的通过本次实验,使学生对贪心算法的概念、基本要素、设计步骤和策略有更深入的理解,掌握贪心算法的原理和应用,并能够运用贪心算法解决实际问题。
二、实验内容本次实验主要涉及以下两个问题:1. 使用贪心算法解决单起点最短路径问题;2. 使用贪心算法解决小船过河问题。
三、实验原理1. 贪心算法贪心算法(又称贪婪算法)是一种在每一步选择中都采取当前最优的选择,从而希望导致结果是全局最优的算法。
贪心算法在每一步只考虑当前的最优解,不保证最终结果是最优的,但很多情况下可以得到最优解。
2. 单起点最短路径问题单起点最短路径问题是指在一个有向无环图中,从某个顶点出发,找到到达其他所有顶点的最短路径。
3. 小船过河问题小船过河问题是指一群人需要划船过河,船只能容纳两个人,过河后需要一人将船开回,问最少需要多久让所有人过河。
四、实验步骤及说明1. 创建图结构,包括顶点数组和边信息。
2. 使用Dijkstra算法求解单起点最短路径问题,得到最短路径和前驱顶点。
3. 使用贪心算法找到两点之间的最短距离,并更新距离和前驱顶点信息。
4. 遍历所有顶点,找到未纳入已找到点集合的距离最小的顶点,并更新其距离和前驱顶点。
5. 最终输出从源顶点到达其余所有点的最短路径。
6. 使用贪心算法解决小船过河问题,按照以下步骤进行:(1)计算所有人过河所需的总时间;(2)计算每次划船往返所需时间;(3)计算剩余人数;(4)重复(2)和(3)步骤,直到所有人过河。
五、实验结果与分析1. 单起点最短路径问题实验中,我们选取了有向无环图G,其中包含6个顶点和8条边。
使用贪心算法和Dijkstra算法求解单起点最短路径问题,得到的实验结果如下:- 贪心算法求解单起点最短路径问题的时间复杂度为O(V^2),其中V为顶点数;- Dijkstra算法求解单起点最短路径问题的时间复杂度为O(V^2),其中V为顶点数。
2. 小船过河问题实验中,我们选取了一群人数为10的人过河,船每次只能容纳2人。
贪心算法实验报告(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)算法源码/**********************单源最短路径问题。
贪心算法求解多机调度问题
多机调度问题一、 问题描述设有n个独立的作业{1,2,…,n},由m台相同的机器进行加工处理。
作业i所需的处理时间为t i。
现约定,任何作业可以在任何一台机器上加工处理,但未完工前不允许中断处理,任何作业不能拆分成更小的子作业。
要求给出一种作业调度方案,使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
二、 问题分析这是一个NP完全问题,到目前为止还没有有效的解法。
本报告根据教材指导及实践经验,采用贪心算法进行分析求解,并进行简单评估。
使用贪心算法,能避免许多复杂的子问题分析,便于直观地剖析主要问题。
在选择贪心算法的基础上,进一步地,我们采用最长处理时间作业优先的贪心选择策略,以求设计出解多机调度问题的较好的近似算法。
预期效果:根据最长处理时间作业优先的原则,理应能够得出直观下比较高效的输出结果。
三、算法设计与分析1.算法输入和输出输入:作业数n,机器数m,作业i对应的处理时间t i(t i在测试时用一个一维数组time表示)输出:总耗费时间2.算法说明最长处理时间作业优先的贪心算法,顾名思义,就是将目前还未被处理的且需要处理时间最长的作业,分配给最先空闲的机器,直到分配完所有的作业为止。
3.算法描述(1)(处理1):当n≤m时,只要将机器i的[0,t i]时间区间分配给作业i即可。
(2)(处理2):当n>m时:i.先将耗时最长的m个作业依次分配给m个机器ii.沿着时间轴,寻找最先得到空闲的机器。
将还未被处理且需要处理时间最长的那个作业分配给此机器iii.重复上一步直到所有作业都被处理完毕4.算法分析当n≤m时,算法需要O(1)时间。
当n>m时,算法需要O(nlogn)时间。
四、算法流程图输入是否n≤m处理1 处理2输出图4-1 多机调度算法流程图五、测试数据及其结果分析1.测试数据当输入n=7, m=3, time={2,14,4,16,6,5,3}时(教材示例),经历处理2,输出结果为17 当输入n=7, m=3, time={4,5,13,9,4,11,2}时,经历处理2,输出结果为20当输入n=18, m=3, time={1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9}时,经历处理2,输出结果为33当输入n=3, m=3, time={2,3,5}时,经历处理1,输出结果为52.结果分析观察可知,贪心算法解此问题,比直观感受要更高效。
5.5主题活动:贪心算法
二 背包问题
装了音响,价值为3000元。但是价值不是最高的,如果是装笔 记本电脑和吉他,总价 值将为3500元。
在这里,贪心策略显然不能获得最优解,但是非常接近。
贪心算法
有时候,只需要找到一个能够大致解决问题的算法 ,此时贪心算法正好可以派上用场,因 为它们实现起来 很容易,得到的结果又与正确结果相当接近。
评一评
请根据本次动手实践情况,在表5-3中相应的位置涂“☆”。 (“非常好”涂☆☆☆☆ ☆,“好”涂☆☆☆,“还需努力”涂☆)
评价内容 理解贪心算法的含义
自评 ☆☆☆☆☆
能用贪心算法解决教室调度问题 ☆☆☆☆☆
能用贪心算法解决背包问题
☆☆☆☆☆
能说出贪心算法的优缺点
☆☆☆☆☆
互评
教师评
☆☆☆☆☆ ☆☆☆☆☆
请根据图思考具体做法。
一 教室调度问题
具体做法: 步骤1:选出结束最早的课,它就是要在这间教室上的第一堂课。 步骤2:选择第一堂课结束后才开始的课。同样,要选择结束得最早的课,这 将是要 在这间教室上的第二堂课。 步骤3:重复步骤1 和步骤2。 美术课结束得最早,为10:00,因此它就是第一堂课。接下来的课必须在10:00 后开 始,且结束得最早。英语课不行,因为它的时间与美术课冲突,数学课满 足条件。最后计算机课与数学课的时间是冲突的,音乐课可以。具体见表
一 教室调度问题
课程 美术 英语 数学 计算机 音乐
开始时间 9:00 9:30 10:00 10:30 11:00
结束时间 10:00 10:30 11:00 11:30 12:00
备注 √ X √ × √
因此根据表格,我们可以在这间教室上如下三堂课。
二 背包问题
课程设计--贪心算法
课程设计--贪心算法数据结构课程设计贪心算法专业软件工程班级B软件121 学号1210701132 学生姓名目录1设计题目 (1)2设计分析 (1)3设计实现 (4)4测试方法 (7)4.1测试目的 (7)4.2 测试输入 (7)4.3 正确输出 (7)4.4 实际输出 (8)5分析与探讨 (8)5.1 测试结果分析 (8)5.2 探讨与改进 (8)6设计小结 (8)1 设计题目有n项任务,要求按顺序执行,并设定第i项任务需要t[i]单位时间。
如果任务完成的顺序为1,2,…,n,那么第i项任务完成的时间为c[i]=t[1]+…+t[i],平均完成时间(Average Completion Time,ACT)即为(c[1]+…+c[n])/n。
本题要求找到最小的任务平均时间。
输入要求:输入数据中包含几个测试案例。
每一个案例的第一行给出一个不大于2000000的整数n,接着下面一行开始列出n个非负整数t(t<=1000000000),每个数之间用空格相互隔开,以一个负数来结束输入。
输出要求:对每一个测试案例,打印它的最小平均完成时间,并精确到0.01。
每个案例对应的输出结果都占一行。
若输入某一个案例中任务数目n=0,则对应输出一个空行。
输入例子:44 2 8 1-1表示有四个任务,各自完成需要的时间单位分别是4,2,8,1,第三行输入-1表示结束。
输出例子:要求程序运行后的输出结果为:6.50。
2 设计分析算法是为了求解一个问题需要遵循的,被青春地指定的简单指令的集合。
任何程序基本上都是要用特点的算法来实现的。
算法性能的好坏,直接决定了所实现程序性能的优劣。
贪心算法通过一系列的选择来的得到一个问题的解。
它所做的每一个选择都是当前的状态下某种意义的最好选择,即贪心选择。
希望通过每次所做的贪心选择导致最终结果问题的一个最优解。
这种启发式的策略并不总能奏效,然而在许多情况下能达到预期的目的。
这个题目属于贪心算法应用中的任务调度问题。
贪心算法实验报告
贪心算法实验报告贪心算法实验报告引言:贪心算法是一种常用的算法设计思想,它在求解最优化问题中具有重要的应用价值。
本实验报告旨在介绍贪心算法的基本原理、应用场景以及实验结果,并通过实例加以说明。
一、贪心算法的基本原理贪心算法是一种以局部最优解为基础,逐步构建全局最优解的算法。
其基本原理是在每一步选择中都采取当前状态下最优的选择,而不考虑之后的结果。
贪心算法通常具备以下特点:1. 贪心选择性质:当前状态下的最优选择一定是全局最优解的一部分。
2. 最优子结构性质:问题的最优解可以通过子问题的最优解来构造。
3. 无后效性:当前的选择不会影响以后的选择。
二、贪心算法的应用场景贪心算法适用于一些具有最优子结构性质的问题,例如:1. 路径选择问题:如Dijkstra算法中的最短路径问题,每次选择当前距离最短的节点进行扩展。
2. 区间调度问题:如活动选择问题,每次选择结束时间最早的活动进行安排。
3. 零钱找零问题:给定一些面额不同的硬币,如何用最少的硬币凑出指定的金额。
三、实验设计与实现本次实验选择了一个经典的贪心算法问题——零钱找零问题,旨在验证贪心算法的有效性。
具体实现步骤如下:1. 输入硬币面额和需要凑出的金额。
2. 对硬币面额进行排序,从大到小。
3. 从面额最大的硬币开始,尽可能多地选择该面额的硬币,直到不能再选择为止。
4. 重复步骤3,直到凑出的金额等于需要凑出的金额。
四、实验结果与分析我们通过对不同金额的零钱找零问题进行实验,得到了如下结果:1. 当需要凑出的金额为25元时,贪心算法的结果为1个25元硬币。
2. 当需要凑出的金额为42元时,贪心算法的结果为1个25元硬币、1个10元硬币、1个5元硬币、2个1元硬币。
3. 当需要凑出的金额为63元时,贪心算法的结果为2个25元硬币、1个10元硬币、1个1元硬币。
通过实验结果可以看出,贪心算法在零钱找零问题中取得了较好的效果。
然而,贪心算法并不是适用于所有问题的万能算法,它的有效性取决于问题的特性。
算法分析与设计实验报告--贪心法 (2)
Dijkstra方法的基本思想是从vs出发,逐步地向外探寻最短路。执行过程中,与每个点对应,记录下一个数(称为这个点的标号),它或者表示从vs到该点的最短路的权(称为P标号)、或者是从vs到该点的最短路的权的上界(称为T标号),方法的每一步是去修改T标号,并且把某一个具T标号的改变为具P标号的点,从而使G中具P标号的顶点数多一个,这样至多经过n-1(n为图G的顶点数)步,就可以求出从vs到各点的最短路。
if(D[j]>D[min]+graph[min][j]||D[j]==-1)
{D[j]=D[min]+graph[min][j]; //每次迭代求最小值,最后一次即为到源点的最短路径
P[j]=min;
}
}
}
void main()
{instital(R, B, D, P);
theshortestway(R, B, D, P);
using namespace std;
int const ZUSHU = 5;
int Ling[] = {50,20,10,5,1};
int GeShu[ZUSHU];
void ZhaoLing(int n)
{for(int i=0;i<ZUSHU;i++)
{GeShu[i] = n / Ling[i];n = n % Ling[i];}
(1)初始时,S中仅含有源节点。
(2)设u是G的某一个顶点,把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径,用数组D[i]记录顶点i当前所对应的最短特殊路径长度。
贪心算法-任务安排问题
●多机调度问题的贪心算法:
数据的表示:
数组t[1..n]: t[i]表示作业j i所需的处理时间。
数组num[1..m]: num[j]表示第j台处理机上处理的任务数。
数组M[1..m,1..n]: M[j, 1..num[j]]表示第j台处理机上处理的作业集。
数组f[1..m]: f[j]表示第j台处理机被占用的时间。
算法MMJA
输入:作业数n, 处理机数目m, 表示n个作业所需的处理时间的数组t[1..n]。
输出:在m台处理机上处理n个作业所需的近似最短时间mint, 表示m台处理机上分别处理的作业数的
数组num[1..m], 表示m台处理机上分别处理的作
业集的数组M[1..m, 1..n]。
num[1..m]=0 ; f[1..m]=0 //初始化
//对t[1..n]按降序地址排序,排序结果返回到数组
a[1..n]中, //使得t[a[1]]>=t[a[2]]>=…>=t[a[n]]。
a=sort(t, n)
for i=1 to n
j=min(f, m) //求f[1..m]的最小值对应的下标。
num[j]=num[j]+1 //在第j台处理机上安排作业
a[i]
M[j, num[j]]=a[i]
f[j]=f[j]+t[a[i]]
end for
mint=max(f, m) //求f[1..m]的最大值。
return mint, num, M
end MMJA
●时间复杂性:Θ(max{nlogn, nm})
思考:如何改进算法,使得时间复杂性降至Θ(nlogn)?。
贪心算法在多机调度问题中的应用
贪心算法在多机调度问题中的应用
贪心算法在多机调度问题中可以应用于任务调度和资源分配的问题。
在多机调度问题中,我们通常需要将一组任务分配到多台机器上,并优化某个指标(如任务完成时间的最小化、机器的负载均衡等)。
贪心算法在多机调度问题中的应用可以通过以下步骤进行:
1. 确定任务的排序方式:根据任务的一些特征,如任务的处理时间、优先级等,确定一种排序方式。
例如,可以按照任务的处理时间递增顺序进行排序。
2. 初始化机器的状态:在开始调度之前,需要初始化每台机器的状态,如设置机器的剩余处理时间、当前任务等。
3. 贪心选择:从排序后的任务列表中,依次选择任务进行分配。
通过贪心选择,选择当前能够使得指标最小化的任务,并将任务分配给剩余处理时间最短的机器。
4. 更新机器状态:根据分配给机器的任务,更新机器的状态,如更新剩余处理时间、当前任务等。
5. 重复步骤3和步骤4,直到所有任务被分配完毕。
贪心算法在多机调度问题中的应用的核心思想是每次选择局部最优解,并希望通过不断地选择局部最优解,最终得到全局最
优解。
然而,需要注意的是,贪心算法并不能保证一定能够得到全局最优解,因此需要根据具体的问题进行分析和验证。
课程设计报告材料-贪心算法:任务调度问题
数据结构课程设计报告贪心算法:任务调度问题的设计专业 学生姓名 班级 学号指导教师 完成日期目录1设计内容 (1)2)输入要求 (1)3)输出要求 (1)2设计分析 (1)2.1排序(将数组按照从小到大排序)的设计 (1)2.2多个测试案例的处理方法的设计 (2)2.3 for循环设计 (2)2.4系统流程图 (2)3设计实践 (2)3.1希尔排序模块设计 (2)3.2 多个测试案例的处理方法的模块设计 (3)4测试方法 (4)5程序运行效果 (4)6设计心得 (6)7附录 (6)贪心算法:任务调度问题的设计1设计内容有n项任务,要求按顺序执行,并设定第I项任务需要t[i]单位时间。
如果任务完成的顺序为1,2,…,n,那么第I项任务完成的时间为c[i]=t[1]+…+t[i],平均完成时间(ACT)即为(c[1]+..+c[n])/n。
本题要求找到最小的任务平均完成时间。
2)输入要求输入数据中包含n个测试案例。
每一个案例的第一行给出一个不大于2000000的整数n,接着下面一行开始列出n各非负整数t(t≤1000000000),每个数之间用空格相互隔开,以一个负数来结束输入。
3)输出要求对每一个测试案例,打印它的最小平均完成时间,并精确到0.01。
每个案例对应的输出结果都占一行。
若输入某一个案例中任务数目n=0,则对应输出一个空行。
2 设计分析这个题目属于贪心算法应用中的任务调度问题。
要得到所有任务的平均完成时间,只需要将各个任务完成时间从小到大排序,任务实际完成需要的时间等于它等待的时间与自身执行需要的时间之和。
这样给出的调度是按照最短作业优先进行来安排的。
贪心算法通过一系列的选择来得到一个问题的解。
它所做的每一个选择都是当前状态下某种意义的最好选择,即贪心选择。
在许多可以用贪心算法求解的问题中一般具有两个重要的性质:贪心选择性质和最有子结构性质。
所谓贪心选择性只是指所求问题的整体最优解可以通过一系列局部最优的选择,即贪心选择来达到,这是贪心算法可行的第一基本要素。
任务调度问题1—贪心算法
任务调度问题1—贪⼼算法这个问题是《算法导论》上的⼀个经典的贪⼼算法问题——单处理器上具有期限和惩罚的单位时间任务调度问题,⽬标是使惩罚最⼩。
输⼊:第⼀⾏⼀个数n,接下来第2⾏到第n+1⾏,第i⾏分别是d[i]和w[i],其中d[i]表⽰第i个任务的时限,w[i]表⽰第i个任务的惩罚,每个任务的完成时间为单位时间。
输出:⼀⾏⼀个数,为最⼩惩罚。
题解:令集合S为所有任务的集合,A为⼀个任务集合,其中所有的任务满⾜条件:存在某种调配⽅式,使得所有任务能在期限前完成,⼜令l为所有A集合的集合。
可以证明,序对M=(S,l)是⼀个拟阵,于是,可以采⽤贪⼼算法解决它。
同时,⼀个任务集合R属于l,当且仅当它满⾜下列条件:R中在期限在不⼤于t的任务不⼤于t个。
于是算法就出来了:先以w[i]为关键字进⾏排序,再进⾏枚举:保持⼀个数组record[i]保存当前集合中时限在不⼤于i的任务个数,对于每⼀个任务ai,将d[i]之后的record更新(加1),若有⼀个d[j]不满⾜条件,则继续检查下⼀个,反之,将它的惩罚从总惩罚中减去。
最后得到的总惩罚即最⼩惩罚。
代码:1 #include <iostream>2 #include <fstream>3using namespace std;4 ifstream fin("TSP.in");5 ofstream fout("TSP.out");6int w[2001],d[2001]; //w[i]指第i号任务的逾期惩罚,d[i]指第i号任务的期限,每个任务都是单位时间;7int record[2001];8int Max,ans;9int partion(int *a,int start,int end)10 {11int i=start,j=start-1,t=0;12for(i=start;i<=end;i++)13 {14if(a[i]>=a[end])15 {16 j++;17 t=a[i];18 a[i]=a[j];19 a[j]=t;20 t=d[i];21 d[i]=d[j];22 d[j]=t;23 }24 }25return j;26 }27int quicksort(int *a,int start,int end)28 {29if(start>=end)30return0;31int j=partion(a,start,end);32 quicksort(a,start,j-1);33 quicksort(a,j+1,end);34return0;35 }36int main()37 {38int n=0,i=0,j=0;39 fin>>n;40for(i=1;i<=n;i++)41 {42 fin>>d[i]>>w[i];43 }44 quicksort(w,1,n);45for(i=1;i<=n;i++)46 {47if(d[i]>=n+1)48 {49 Max+=w[i];50continue;51 }52for(j=d[i];j<=n;j++)53 {54if(record[j]+1>j)55break;56 }57if(j==n+1)58 {59for(j=d[i];j<=n;j++)60 record[j]++;61 Max+=w[i];62 }63 }64for(i=1;i<=n;i++)65 ans+=w[i];66 ans-=Max;67 fout<<ans<<endl;68 }拟阵作为⼀种⾼级结构,是在贪⼼算法的研究中所必须掌握的,同时也由于它的难度较⼤,更需要我们来认真学习。
实验二贪心法作业调度
一、验目的
1.掌握贪心算法的基本思想
2.掌握贪心算法的典型问题求解
3.进一步多级调度的基本思想和算法设计方法
4.学会用贪心法分析和解决实际问题
二、实验内容
设计贪心算法实现作业调度,要求按作业调度顺序输出作业序列。如已知n=8,效益p=(35, 30, 25, 20, 15, 10, 5,1),时间期限d=(4, 2, 4, 5, 6, 4, 5, 7),求该条件下的最大效益。
t++;
S[y][t]=x;
//printf("%d\n",S[j][t]);
}
void Greedy(intt[],intd[],intp[]){
inti,j;
for(i=0;i<M;i++)
{ S[i][0]=p[i];
d[i]=t[i];}
for(i=M;i<N;i++)
{j=Minlable(d);
t=j;}
b[i]=t;
}
}//选择排序t[N]并且将对应的作业号存储在数组p[N]中.
intMinlable(intd[]){
inti,t=0;
for(i=0;i<M;i++)
if(d[t]>d[i])
t=i;
return t;
}
voidchazhao(inty,intx){
intt=0;
while(S[y][t]!=-1)
chazhao(j,p[i]);
d[j]=d[j]+t[i];
}
}//贪心算法.
intmain(){
intc,n=N,m=M,t[N],d[N],p[N];
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构课程设计报告贪心算法:任务调度问题的设计专业学生姓名班级学号指导教师完成日期贪心算法:任务调度问题的设计目录1设计内容 (1)2)输入要求 (1)3)输出要求 (1)2设计分析 (1)2.1排序(将数组按照从小到大排序)的设计 (1)2.2多个测试案例的处理方法的设计 (2)2.3 for循环设计 (2)2.4系统流程图 (2)3设计实践 (2)3.1希尔排序模块设计 (2)3.2 多个测试案例的处理方法的模块设计 (3)4测试方法 (4)5程序运行效果 (4)6设计心得 (6)7附录 (6)数据结构课程设计报告(2017)贪心算法:任务调度问题的设计1设计内容有n项任务,要求按顺序执行,并设定第I项任务需要t[i]单位时间。
如果任务完成的顺序为1,2,…,n,那么第I项任务完成的时间为c[i]=t[1]+…+t[i],平均完成时间(ACT)即为(c[1]+..+c[n])/n。
本题要求找到最小的任务平均完成时间。
2)输入要求输入数据中包含n个测试案例。
每一个案例的第一行给出一个不大于2000000的整数n,接着下面一行开始列出n各非负整数t(t≤1000000000),每个数之间用空格相互隔开,以一个负数来结束输入。
3)输出要求对每一个测试案例,打印它的最小平均完成时间,并精确到0.01。
每个案例对应的输出结果都占一行。
若输入某一个案例中任务数目n=0,则对应输出一个空行。
2 设计分析这个题目属于贪心算法应用中的任务调度问题。
要得到所有任务的平均完成时间,只需要将各个任务完成时间从小到大排序,任务实际完成需要的时间等于它等待的时间与自身执行需要的时间之和。
这样给出的调度是按照最短作业优先进行来安排的。
贪心算法通过一系列的选择来得到一个问题的解。
它所做的每一个选择都是当前状态下某种意义的最好选择,即贪心选择。
在许多可以用贪心算法求解的问题中一般具有两个重要的性质:贪心选择性质和最有子结构性质。
所谓贪心选择性只是指所求问题的整体最优解可以通过一系列局部最优的选择,即贪心选择来达到,这是贪心算法可行的第一基本要素。
对于一个具体问题,要确定它是否具有贪心选择性质,必须证明每一步所做的贪心选择最终将会得到问题的一个整体最优解。
首先考察问题的一个整体最优解,并证明可修改这个最优解,使其以贪心选择开始。
而且做了贪心选择后,原问题简化为一个规模更小的类似子问题。
然后,用数学归纳法证明,通过每一步做贪心选择,最终可得到问题的一个整体最优解。
其中,证明贪心选择后问题简化为规模更小的类似子问题的关键在于利用该问题的最优子结构性质。
当一个问题的最优解包含着它的子问题最优解时,称此问题具有最优子结构性质,这个性质是该问题可用贪心算法求解的一个关键特征。
2.1排序(将数组按照从小到大排序)的设计排序的方法有很多,如:冒泡排序、希尔排序、堆排序等,这些排序的方法都可以使用。
这里采用希尔排序来实现。
它的基本思想是:先取一个小于n的整数d1作为第一个增量;这里选取n的一半作为第一个增量(increment=n》1),把数组的全部元素分成d1个组。
所有距1贪心算法:任务调度问题的设计离为d1的倍数的记录放在同一组中。
先在各组内进行直接插入排序;然后,取第二个增量d2<d1重复上述的分组和排序,直至所取的增量d1=1(dt<dt-1<···<d2<d1),即所有记录放在同一组中进行直接插入排序位置。
该方法实质上是一种分组插入排序方法。
2.2多个测试案例的处理方法的设计程序实现的时候,要求用户一次可以输入椅子或者多组测试案例的数据,当要迷糊糊的输入完成后,程序经过计算在屏幕上分行显示这几个案例的结果。
因此有多个测试案例的情况下,需要设置一个数组,用来存放么每一组测试案例的计算结果。
2.3 for循环设计明确了可以用最短作业优先的思想后,就可以正式来设计题目的实现了。
首先,输入的测试案例可以有很多组,每一个案例的输入格式都是第一行输入任务的个数,然后下面一行输入每一个任务需要的时间单位,输入完成另起一行,可以再继续输入下一个案例的数据。
最后用一个任意的负数来表示输入的结束。
这样,由于案例的个数开始不得知,所以可以套用一个for循环。
2.4系统流程图3设计实践3.1希尔排序模块设计void Shellsort(long *a,long n){long i,j,increment;long temp;for(increment=n>>1;increment>0;increment>>=1){for(i=increment;i<n;i++)2数据结构课程设计报告(2017){temp=*(a+i);for(j=i;j>=increment;j-=increment){if(temp<*(a+(j-increment)))*(a+j)=*(a+(j-increment));elsebreak;}*(a+j)=temp;}}}3.2 多个测试案例的处理方法的模块设计double r[100];/*用来存放每个测试案例的计算结果*/j=0;/*记录测试案例的个数*//*读入用户的输入,若当前输入为负数,则程序终止*/for(n=0;n>=0;){scanf("%ld",&n);if(n>2000000){printf("too much for the project!\n");exit(0);}if(n>0){b=(long * )malloc(n * sizeof(long));a=b;for(i=0;i<n;i++){scanf("%ld",b+i);/*检查输入的数据是否大于1000000000*/if(*(b+i)>1000000000){printf("too much for the project!\n");exit(0);}/*对输入中出现任务时间为负数的异常处理*/if(*(b+i)<0){printf("input error!\n");return 0;}}Shellsort(b,n);/*计算平均完成时间*/for(i=n,r[j]=0.0;i>0;i--,a++){3贪心算法:任务调度问题的设计r[j]+=(double)*a/(double)n*i;}j++;free(b);}/*当n为0时,标志相应的r数组值为-1.输出时遇到-1,则输出一个空行*/ else if(n==0){r[j++]=-1;}}for(i=0;i<j;i++){if(r[i]==-1)printf("\n");/*输出一个空行8*/else printf("%.2f\n",r[i]);/*输出的结果要求精确到0.01*/ }return 1;}4测试方法这个程序主要需要测试以下几个方面:●当任务个数为0时,需要对应输出一个空行。
●当输入的作业数目大于2000000,或者单个作业完成的时间大于1000000000的时候,程序要求报错。
●另外,当任务数比较大的时候,输入对应的任务时间是要仔细,务必保证输入的任务个数与要求的任务数一直。
如果出现输入的任务数与n值不相符时,程序应会报错,输出“input error!”的错误。
5 程序运行效果5.1正确输入正确输出。
4数据结构课程设计报告(2017)图5.1 正确输入输出数据图5.2异常输入数据5.2.1输入数据超出2000000。
图5.2.1 超出作业数目异常图5.2.2任务数较大时输出任务个数与要求任务数不一致。
图5.2.2 任务数不一致异常图5.2.3单个作业完成时间大于1000000000。
图5.2.3 单个作业完成时间超出异常图5贪心算法:任务调度问题的设计6 设计心得通过本次课程设计我在数据结构编程方面领悟了很多。
看到这个选题的时候,其实我并不知道贪心算法是什么算法,甚至都无从下手去设计关于这个的编程以及它的报告。
虽然在中间写的过程中还有很多不会的东西,但是通过查看书本和资料还有问同学,基本上都解决了。
但仍然有一些有待提高的地方,比如在排序前后的结果比较和如果运行时间长的任务在等待很长时间都没有运行等较高的要求还没有解决。
设计根据书本以及老师和同组同学的帮助,本次设计也算是完成了。
我在这次设计中其实自己也没花好时间去完成。
关于程序方面也有许多的不明白。
但是通过本次设计,我也领悟到自身有许多的不足。
以后会更加花心思,下功夫去完成好每一个老师给予的任务,从而提高自己。
我觉得课程设计的作用一方面是最基本的就是要完成这一科目,差不多也是对自己的一个阶段性的总结;还有就是在整个设计的过程中,让我们认真的独立思考,在和同学交流的过程中也增强了我们的语言组织能力和彼此之间的友谊。
通过课程设计让我们不断的发现自己的不足从而去改善,这是一种学习的态度,不仅仅是在这次的课程设计中,在以后的无论生活还是学习方面都应该注意和努力改善。
7附录#include<stdio.h>#include<stdlib.h>void Shellsort(long *a,long n);int main(){long n,i,j;long *a,*b;double r[100];j=0;for(n=0;n>=0;){scanf("%ld",&n);if(n>2000000){printf("too much for the project!\n");exit(0);}if(n>0){b=(long* )malloc(n * sizeof(long));a=b;for(i=0;i<n;i++){scanf("%ld",b+i);if(*(b+i)>1000000000){6数据结构课程设计报告(2017)printf("too much for the project!\n");exit(0);}if(*(b+i)<0){printf("input error!\n");return 0;}}Shellsort(b,n);for(i=n,r[j]=0.0;i>0;i--,a++){r[j]+=(double)*a/(double)n*i;}j++;free(b);}else if(n==0){r[j++]=-1;}}for(i=0;i<j;i++){if(r[i]==-1)printf("\n");else printf("%.2f\n",r[i]);}return 1;}void Shellsort(long *a,long n){long i,j,increment;long temp;for(increment=n>>1;increment>0;increment>>=1){for(i=increment;i<n;i++){temp=*(a+i);for(j=i;j>=increment;j-=increment){if(temp<*(a+(j-increment)))*(a+j)=*(a+(j-increment));elsebreak;}*(a+j)=temp;}}}7。