一个更快的带有期限的作业排序问题
算法-带有期限的作业排序问题
姓名:
学号:
问题解析(对问题的分析、解题思路与解题方法):
对当前正在考虑的作业,按限期大小采用一种“插入排序”的方式,尝试将其“插入”到一个按限期从小到大顺序构造的作业调度序列中,以此判断是否能够合并到当前部分解J中。如果可以,则插入到序列中,形成新的可行解序列。否则,舍弃该作业。
r--;
if(d[J[r]] <= d[i] && d[i]>r)
{
for(int j=k; j>r; j--)
J[j+1] = J[j];
J[r+1] = i;
k++;
}
}
return k;
}
fjs算法:
int FJS(int *D,int n,int b,int *J,int *Q)
{
int i,*F,*P,j,I,m,k;
具体如下:假设n个作业已经按照效益值从大到小的次序,即p1>=p2...>=pn的顺序排列好,每个作业可以在单位时间内完成,并具有相应的时间期限;且至少有一个单位时间可以执行作业:
首先,将作业1存入部分解J中,此时J是可行的;
然后,依次考虑作业2到n。假设已经处理了i-1个作业,其中有K个作业计入了部分解J中:J(1),J(2),...,J(K),且有
if(F[j]!=0)
{
k=k+1;
J[k]=i;
Q[F[j]]=i;
m=F[j];
I=FIND(P,F[j]-1);
UNION(P,I,j);
F[j]=F[I];
}
}
return k;//返回最优解的个数
}
生产运作管理---第十一章流水作业的排序问题
假设条件
1.一个工件不能同时在几台不同的机器上加工。 2.工件在加工过程中采取平行移动方式,即当上一道工
序完工后,立即送下道工序加工。 3.不允许中断。当一个工件一旦开始加工,必须一直进
行到完工,不得中途停止插入其它工件。 4.每道工序只在一台机器上完成。 5.工件数、机器数和加工时间已知,加工时间与加工顺
Fi----工件Ji 的流程时间,即工件在车间的实际停留时间,在工
件都已到达的情况下, Fi= Pi+ Wi
Li----工件Ji 的延误时间, Li= Ci- di , Li<=0 按期或完成提前;
Li>0 延误
Fmax----最长流程时间, Fmax=max{Fi}
二、排序问题的分类和表示法
1、排序问题的分类:
排序问题常用四个符号来描述: n/m/A/B
其中, n-----工件数; m-----机器数; A----车间类型; F=流水型排序, P=排列排序 G=一般类型,即单件型排序 B-----目标函数
三、流水作业排序问题
1、最长流程时间Fmax的计算
举例:有一个6/4/p/ Fmax问题,其加工时 间如下表所示。当按顺序S=(6,1,5, 2,4,3)加工时,求Fmax。
(a) J1 - J2 - J3- J4 - J5
A B
30
(b) J4 - J2 - J3- J5 - J1
A B
26
比较
可以看出,初始作业顺序的总加工周期是 30,用约翰逊法排出的作业顺序总加工周 期是26,显然后者的结果优于前者。
两台机器排序问题的算法(续)
I
1
2
3
4
5
6
Ai
作业排序与控制.
n/1 排序
在评价作业排序方案时,工件流程时间、 工件延期交货天数、时间跨度和平均工 件库存数是几个主要的绩效评价指标。
7
n/1排序问题
例如,某加工车间要为2003年9月份加工的6批产品 进行作业排序,每批的件数相同,都是1000件,公 司对各种产品的加工时间都设定了工时定额,销售 部门提出了各种产品的预定交货期。
2
作业排序问题的概念
2、作业排序的主要目标 满足交货日期的需要。 降低在制品库存,加快流动资金周转。 缩短提前期。 降低机器设备的准备时间和准备成本。 充分利用机器设备和劳动力。
3
作业排序问题的概念
3、作业排序问题的分类
根据行业的不同,排序问题可分为制造业的排序问 题和服务业的排序问题。 根据排序的对象分,可分为劳动力(或服务者)排 序和生产作业(或服务对象)排序。 对于多台设备的排序问题,又可根据加工路线分为 单件作业(Job shop)排序问题和流水作业(Flow shop)排序问题。 按工件或顾客到达工作地或服务台的具体情况,可 分为静态排序问题和动态排序问题。
8
n/1排序问题
方案1:遵循FCFS规则排序。FCFS的排序顺序是按照待加工的产品从上 一道工序转到该加工工序的先后顺序来确定的,即如表11-3所示, BY050→GL310→GM270→BY471 →LN002→LY120
检验顺序
BY050 GL310 GM270 BY471 LN002 LY120
9
n/1排序问题
方案2:采用SPT规则。SPT优先规则为优先选择加工时间最短的产品。根 据SPT规则,这六批不同的产品在该加工工序的顺序为 LN002→LY120→BY471→GL310→GM270→BY050
最短作业优先算法例题
最短作业优先算法例题最短作业优先算法(Shortest Job First,简称SJF)是一种用于调度作业的算法,根据作业的执行时间来确定优先级。
具体例题如下:假设有5个作业,它们的执行时间分别为:作业1:5个单位时间作业2:2个单位时间作业3:9个单位时间作业4:7个单位时间作业5:3个单位时间按照最短作业优先算法进行调度,首先选择执行时间最短的作业来执行。
1. 初始状态下,作业队列为空。
2. 比较所有作业的执行时间,找到执行时间最短的作业作为第一个执行的作业。
最短执行时间为2,因此选择执行时间为2个单位时间的作业2,并将其加入作业队列。
作业队列:作业23. 接下来,比较作业队列中的作业和剩下的作业的执行时间,选择执行时间最短的作业。
作业队列中只有一个作业,无需比较,因此选择剩下的作业中执行时间最短的作业。
最短执行时间为3,因此选择执行时间为3个单位时间的作业5,并将其加入作业队列。
作业队列:作业2 -> 作业54. 继续比较作业队列中的作业和剩下的作业的执行时间,选择执行时间最短的作业。
最短执行时间为5,因此选择执行时间为5个单位时间的作业1,并将其加入作业队列。
作业队列:作业2 -> 作业5 -> 作业15. 继续比较作业队列中的作业和剩下的作业的执行时间,选择执行时间最短的作业。
最短执行时间为7,因此选择执行时间为7个单位时间的作业4,并将其加入作业队列。
作业队列:作业2 -> 作业5 -> 作业1 -> 作业46. 最后一个作业3的执行时间为9,因此将其加入作业队列。
作业队列:作业2 -> 作业5 -> 作业1 -> 作业4 -> 作业3最终的作业队列为:作业2 -> 作业5 -> 作业1 -> 作业4 -> 作业3按照最短作业优先算法的调度顺序,作业将按照执行时间从短到长的顺序被执行。
五种作业排序规则最短作业时间规则
五种作业排序规则最短作业时间规则当多项任务(零件)排队等候某个工作中心加工时,哪项任务应当优先安排?这就是作业优先次序安排(简称为作业排序)要解决的问题。
常用的排序规则有:
①先到先服务规则(FCFS排序):即任务的处理顺序是按照其到达工作中心的先后次序依次进行。
②最短作业时间规则(SPT排序):即在所有排队等候某个工作中心加工的任务中,选择作业时间(准备时间十加工时间)最短的那一件最先加工。
③超限最短加工时间规则:即事先设定一个排队等候时间限度,对于等候时间超过此时间限度的任务,优先安排其中作业时间最短的任务。
如果没有哪项任务的排队等候时间超限,则按最短作业时间规则排序。
④最早到期规则:即在所有排队等候某个工作中心加工的任务中,按照计划交货期从早到晚的顺序,最先安排计划交货期最早的任务,而不管该项任务何时到达该工作中心。
⑤最短松弛时间规则:所谓松弛时间,等于某项任务距离计划交货期的剩余时间与该项任务的作业时间之差。
而最短松弛时间规则,
是将最高优先级分派给具有最短松弛时间的任务,而不管其计划交货期的早晚。
作业排序的要求
作业排序的要求作业排序是指在完成多个作业时,合理安排作业的顺序和时间分配,以提高工作效率和质量。
下面将从以下几个方面介绍作业排序的要求。
一、根据紧急程度排序在进行作业排序时,首先需要根据作业的紧急程度来确定其优先级。
紧急的作业需要优先处理,以避免延误或影响其他工作的进行。
例如,如果有一个重要的报告需要在明天上午之前完成,而另一个作业只是一个日常任务,那么应当优先完成重要的报告。
二、根据重要程度排序除了紧急程度外,作业的重要程度也是作业排序的重要考虑因素。
重要的作业可能对项目的整体进展和结果产生较大的影响,因此应优先处理。
例如,如果有一个关键的客户提出了一个紧急请求,而另一个作业只是一个例行性的任务,那么应当优先处理关键客户的请求。
三、根据工作量排序作业的工作量也是作业排序的一个关键指标。
通常情况下,工作量较小的作业可以更快地完成,因此可以优先处理。
例如,如果有一个简单的数据分析任务和一个复杂的软件开发任务,那么可以先完成数据分析任务,以提高整体工作效率。
四、根据依赖关系排序在进行作业排序时,还需要考虑作业之间的依赖关系。
如果一个作业依赖于另一个作业的结果,那么应当先完成被依赖的作业,再进行下一个作业。
例如,如果一个作业需要另一个作业的输入数据才能开始,那么应当先完成提供输入数据的作业,再开始下一个作业。
五、根据时间限制排序有些作业可能有严格的时间限制,需要在规定的时间内完成。
在进行作业排序时,应当优先处理这些有时间限制的作业,以确保按时完成。
例如,如果有一个会议的演讲稿需要在下午2点之前提交,那么应当优先处理演讲稿的撰写和整理工作。
六、根据资源可用性排序作业排序还需要考虑资源的可用性。
如果某个作业需要特定的资源或设备才能完成,那么应当优先处理其他不需要这些资源或设备的作业。
例如,如果一个作业需要使用一台特定的机器进行测试,而这台机器正在被其他人使用,那么可以先处理其他不需要使用这台机器的作业。
作业排序是一项重要的工作管理技巧,可以帮助我们合理安排作业的顺序和时间分配,提高工作效率和质量。
带有限期的作业排序
带有限期的作业排序问题的描述:带有期限的作业排序要解决的是操作系统中单机、无资源约束且每个作业可在等量的时间内完成的作业调度问题。
把这个问题形式化描述为:①要在一台机器上处理n个作业,每个作业可以在单位时间内完成②每个作业i都有一个期限值d i,d i>0③当作业在它规定的期限值前完成,就可以获得的效益p i,p i>0问题求解的目标是:问题的可行解是这n个作业的一个子集合J。
J中的每个作业都能在各自的截止期限前完成后,产生一个作业效益之和。
我们的目标就是找到一个子集J,J中的每个作业都能在各自的截止期限前完成,并且使得作业效益值的和最大。
这个作业的一个子集合J就是所求的最优解。
带有期限的作业排序的一个例子:例3.2 n=4,(p1,p2,p3,p4)=(100,10,15,20),(d1,d2,d3,d4)=(2,1,2,1)。
这个问题的最优解为第7个,所允许的处理顺序是:先处理作业4,在处理作业1。
在时间0开始处理作业4而在时间2完成对作业1的处理。
可行解处理顺序效益值1 {1} 1 1002 {2} 2 103 {3} 3 154 {4} 4 205 {1,2} 2,1 1106 {1,3} 1,3或3,1 1157 {1,4} 4,1 1208 {2,3} 2,3 259 {3,4} 4,3 35带有期限的作业排序贪心算法度量标准的选取:我们的目标是作业效益值的和最大,因此首先把目标函数作为度量标准。
首先把作业按照它们的效益值作一个非增次序的排序。
以例3.2来说,作业根据效益值排序后为作业1、4、3、2。
求解时首先把作业1计入J,由于作业1的期限值是2,所以J={1}是一个可行解。
接下来计入作业4。
由于作业4的期限值是1而作业1的期限值是2,可以先完成作业4后再完成作业1,所以J={1, 4}是一个可行的解。
然后考虑作业3,但是作业3的期限值是2,计入J后就没有办法保证J中的每一个作业都在期限值内完成,因此计入作业3后不能构成一个可行解。
带期限的作业调度算法[整理]
算法设计思想:如果J是作业的可行子集,那么可以使用下述规则来确定这些作业中的每一个作业的处理时间:若还没给作业i分配处理时间,则分配给它时间片[a-1,a],其中a应尽量取最大且时间片[a-1,a]是空的。
此规则就是尽可能推迟对作业i的处理。
于是,在将作业一个一个地装配到J中时,不必为接纳新作业而去移动J中那些已分配了时间片的作业。
如果正被考虑的新作业不存在像上面那样定义的a,这个作业就不能计人J。
各作业的效益值放在P[ ]中,并按效益值非增次序排列,期限值放在D[ ]中,F[ ]用于存放最大期限值,J[ ]用于存放最优解,Q[ ]用于存放作业的调度次序。
算法描述:line procedure FJS(D,n,b,j, k)//找最优解J=J(1),…J(K)////D(1),…..,D(n)是期限值,n>=1.作业已按//P(1)>=P(2)>=….P(n)被排序,//b=min{n,max{D(i)}}//integer b,i,k,n,j ,l,D(n),J(n),F(0:b),p(0:b)for i=1to n do //将树置初值//F(i)ßi;p(i)ß-1repeatKß0 //初始化J//for iß1 to n do //使用贪心规则//jß FIND(min(n,D(i) ))if F(j)不为0then kßk+1;J(K)ßi //选择作业i//lßFIND(F(j)-1); call UNION(l,j)F(j)ßF(1)endifrepeatend FJS算法分析:此算法的时间复杂度为:O(na(2n,n))(Ackerman函数的逆函数。
);它用于F和P的空间至多为2n个字节。
贪心法-带有限期的作业排序
贪⼼法-带有限期的作业排序问题描述–假定在⼀台机器上处理n个作业,每个作业均可在单位时间内完成;同时每个作业i都有⼀个截⾄期限di>0,当且仅当作业i在其截⾄期限以前被完成时,则获得pi>0的效益。
–问题:求这n个作业的⼀个⼦集J,其中的所有作业都可在其截⾄期限内完成。
——J是问题的⼀个可⾏解。
–可⾏解J中的所有作业的效益之和是 i<j∑Pi,具有最⼤效益值的可⾏解是该问题的最优解。
⽬标函数:–约束条件:所有的作业都应在其期限之前完成–分析如果所有的作业期限“⾜够宽松” ,⽽使得多有作业都能在其期限之内完成,则显然可以获得当前最⼤效益值;否则,将有作业⽆法完成——决策应该执⾏哪些作业,以获得最⼤可能的效益值。
n=4,(p1,p2,p3,p4)=(100,10,15,20)和(d1,d2,d3,d4)=(2,1,2,1)。
可⾏解如下表所⽰:问题的最优解是⑦。
所允许的处理次序是:先处理作业4再处理作业1。
量度标准:下⼀个要计⼊的作业将是使得在满⾜所产⽣的J是⼀个可⾏解的限制条件下让得到最⼤增加的作业。
处理规则:按pi的⾮增次序来考虑这些作业。
procedure JS(D,J,n,k)//D(1),…,D(n)是期限值。
n≥1。
作业已按p1≥p2≥…≥pn的顺序排序。
J(i)是最优解中的第i个作业,1≤i≤k。
终⽌时, D(J(i))≤D(J(i+1)), 1≤i<k//integer D(0:n),J(0:n), i, k, n, rD(0)←J(0)←0 //初始化//k←1;J(1)←1 //计⼊作业1//for i←2 to n do //按p的⾮增次序考虑作业。
找i的位置并检查插⼊的可⾏性//r←kwhile D(J(r))>D(i) and D(J(r)) ≠r do r←r-1 repeatif D(J(r))≤D(i) and D(i)>r then //把i插⼊到J中//for i←k to r+1 by -1 doJ(i+1) ←J(i) //将插⼊点的作业后移⼀位//repeatJ(r+1) ←i;k←k+1endifrepeatend JS#include <iostream>using namespace std;/*D(1),…,D(n)是期限值。
短作业优先算法
短作业(进程)优先调度算法1.短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。
而短进程(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业(进程)的平均等待时间,提高系统吞吐量。
该算法对长作业不利,完全未考虑作业的紧迫程度。
2.流程图3.代码#include<iostream.h>#include<string.h>#include<stdlib.h>struct sjf{char name[10];float arrivetime;float servicetime;float starttime;float finishtime;float zztime;float dqzztime;};sjf a[100];void input(sjf *p,int N){ int i;printf("intput the process's name & arrivetime & servicetime:\nfor exmple: a 0 100\n");for(i=0;i<=N-1;i++){printf("input the %dth process's information:\n",i+1);scanf("%s%f%f",&p[i].name,&p[i].arrivetime,&p[i].servicetime);}}void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N) {int k;printf("run order:");printf("%s",p[0].name);for(k=1;k<N;k++){printf("-->%s",p[k].name);}printf("\nthe process's information:\n");printf("\nname\tarrive\tservice\tstart\tfinish\tzz\tdqzz\n");for(k=0;k<=N-1;k++){ printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n",p[k].na me,p[k].arrivetime,p[k].servicetime,p[k].starttime,p[k].finishtime, p[k].zztime,p[k].dqzztime);}}//pai xuvoid sort(sjf *p,int N){for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arrivetime<p[j].arrivetime){sjf temp;temp=p[i];p[i]=p[j];p[j]=temp;}}//yun xing jieduanvoid deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N) { int k;for(k=0;k<=N-1;k++){if(k==0){p[k].starttime=p[k].arrivetime;p[k].finishtime=p[k].arrivetime+p[k].servicetime;}else{p[k].starttime=p[k-1].finishtime;p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}}for(k=0;k<=N-1;k++){p[k].zztime=p[k].finishtime-p[k].arrivetime;p[k].dqzztime=p[k].zztime/p[k].servicetime;}}void sjff(sjf *p,int N){floatarrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dq zztime=0;sort(p,N);for(int m=0;m<N-1;m++){if(m==0)p[m].finishtime=p[m].arrivetime+p[m].servicetime;elsep[m].finishtime=p[m-1].finishtime+p[m].servicetime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arrivetime<=p[m].finishtime)i++;}float min=p[m+1].servicetime;int next=m+1;//m+1=nfor(int k=m+1;k<m+i;k++){if(p[k+1].servicetime<min){min=p[k+1].servicetime;next=k+1;}}sjf temp;temp=p[m+1];p[m+1]=p[next];p[next]=temp;}deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime, N);Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime ,N);}int main(){ int N;printf("------短作业优先调度算法------\n");printf("input the process's number:\n");scanf("%d",&N);input(a,N);sjf *b=a;sjf *c=a;sjff(b,N);system("PAUSE");}4.运行结果5.心得体会课程设计结束了,在这次的课程设计中不仅检验了我所学习的知识,也培养了我如何去做一件事情,又如何完成一件事情的能力。
短作业优先调度算法例题详解
短作业优先调度算法例题详解
【最新版】
目录
1.短作业优先调度算法的概念和原理
2.短作业优先调度算法的例题
3.短作业优先调度算法的例题详解
正文
一、短作业优先调度算法的概念和原理
短作业优先调度算法(Shortest Job First, SJF)是一种常见的作业调度算法,其基本原理是优先执行估计运行时间最短的作业,直至完成。
当有两个或两个以上的作业都等待执行时,选择估计运行时间最短的作业执行。
这种算法能够使得平均等待时间最短,从而提高系统的效率。
二、短作业优先调度算法的例题
假设有一个计算机系统,其中有如下三个作业:
作业 1:运行时间为 20 分钟
作业 2:运行时间为 30 分钟
作业 3:运行时间为 10 分钟
系统按照短作业优先调度算法进行调度。
三、短作业优先调度算法的例题详解
1.作业 1、作业 2 和作业 3 都到达,系统按照短作业优先调度算法选择运行时间最短的作业 1 执行。
2.作业 1 执行完毕,作业 2 和作业 3 等待执行。
3.系统选择运行时间最短的作业 3 执行。
4.作业 3 执行完毕,作业 2 等待执行。
5.系统选择运行时间最短的作业 2 执行。
最终,三个作业的完成顺序为作业 1、作业 3、作业 2,平均等待时间为(20+10)/3=10 分钟。
通过这个例题,我们可以看到短作业优先调度算法能够使得平均等待时间最短,从而提高系统的效率。
然而,这种算法也有其不足之处,即长作业可能会被频繁地中断,从而影响系统的稳定性。
带期限的作业排序问题
带期限的作业排序问题(1)答:c`(x)的设计思路:当x=1时,c`(x)为所有作业的罚款金额总和,某节点m的估计值为c`(x),并对其进行扩展时,其有效的子节点a的c`(x)为m的c`(x)-a的罚款金额。
对于u(x)初始时为作业罚款金额总和。
之后,若队列中的某一节点b的c`(x)最小且小于u(x),则使u(x) =b. c`(x)(2)(3)当某节点的已经被罚款项即c(x)>U,则封杀此节点。
(4)当从根开始到当前要加入的节点这条路径中,共花费时间costtime ,最大截止期限为maxdeadtime,若maxdeadtime<costtime则此节点不可行,否则可行.(5)主要结构及类型说明node queue[1000];//存放状态空间树中的节点Node结构在构造状态空间树时使用struct node{int number;//所代表的作业在source[]的下标int mayfine;//可能的罚款的金额即罚款金额的上限int currentfine;//到此节点止已罚款的金额bool iskilled;//是否被杀死int timecost;//从根节点到此节点为止已花费的时间int parent;//父节点在queue[]的下标};Tast结构在输入作业信息时使用struct task{int number;//作业的序号int fine;//罚款金额int deadline;//截止期限int time;//完成此作业所需的时间};int ans=0;//最小上界值在queue的下标int minmayfine;//队列中活结点的罚款上限的最小值即Uint activenumber=1;//活结点的数目const int N = ?;//N表示作业数int size = 1;//当前队列中的元素个数(6)程序代码思想://使作业按截至期限的非降序排列,则对一个父节点s,要加入一个节点m,只要m 的截至期限大于等于s.timecost+m所代表的作业的time#include<iostream>#include<algorithm>using namespace std;struct node{int number;//选择的节点在source[]的下标int mayfine;//可能的罚款的金额即罚款金额的上限int currentfine;//到此节点止已罚款的金额bool iskilled;//是否被杀死int timecost;//从根节点到此节点为止已花费的时间int parent;//父节点在queue[]的下标};struct task{int number;//作业的序号int fine;//罚款金额int deadline;//截止期限int time;//完成此作业所需的时间};//节点被杀死的条件是已罚款的金额超过了最小罚款金额即currentfine>mayfinenode queue[1000];//存放状态空间树const int N = 4;//N表示作业数task source[N+1] = {{0,0,0,0}, {1,5,1,1}, {2,10,3,2}, {3,6,2,1}, {4,3,1,1}};//作业集合int ans=0;//最小上界值在queue的下标int minmayfine;//队列中活结点的罚款上限的最小值int activenumber=1;//活结点的数目void init()//初始化队列{for (int i =1; i <= N; i++){minmayfine +=source[i].fine;}queue[0].mayfine = minmayfine;queue[0].currentfine =0;queue[0].iskilled =0;queue[0].number = 0;//作业的序号queue[0].parent = -1;queue[0].timecost =0;}bool greater(task x,task y){if (x.deadline <= y.deadline)return 1;elsereturn 0;}//aloca为节点m在queue[]的下标,b为m的子节点x的作业在source[]的下标,获取x 到目前为止已罚款数int getfine(int aloca,int b){int a = queue[aloca].number;//a为节点m在source[]中的下标int fine = queue[aloca].currentfine;for(int i = a+1;i<b;i++)fine += source[i].fine;return fine;}void construction(){sort(source+1,source+N+1,greater);//截止期限按非降序排列int size = 1;//当前队列中的元素个数int active =0;//正在扩展的活结点的下标int a;int costtime;while (activenumber != 0){//当一个节点已罚的款数大于最终罚款的上界的最小值,则杀死并查找下一个活结点if(queue[active].currentfine > minmayfine ){queue[active].iskilled = 1;active++;activenumber--;//活结点减少1continue;}//向后选择作业,直到所有的组合都选择完a=queue[active].number+1;while (a<=N){costtime = queue[active].timecost+source[a].time;if (costtime <= source[a].deadline){queue[size].currentfine = getfine(active,a);//a为在source[]中的下标queue[size].iskilled =0;queue[size].mayfine = queue[active].mayfine - source[a].fine;queue[size].parent = active;queue[size].number = a;queue[size].timecost = costtime;//寻找队列中最终罚款的上限的最小值if(queue[size].mayfine < minmayfine){minmayfine = queue[size].mayfine;//答案节点的上界即Uans = size;}size++;//队列长度增加activenumber++;}//外层if结束a++;}//内层while结束//一个节点完全扩展完了,就会被杀死,并且活结点数目减少1queue[active].iskilled =1;activenumber--;active++;//扩展下一个节点}//外层while结束while (ans != 0){cout<<source[queue[ans].number].number<<" ";ans = queue[ans].parent;}cout<<endl;}void main(){init();construction();}. .。
5.3.2一种更快的作业排序算法
一种更快的作业排序算法从带有限期的作业排序贪心算法可以看到:当找到下一个要插入队列中的作业的位置后,需要将队列中位于它后面的所有作业均向后移动一个位置,算法中有许多时间浪费在移动作业的位置上。
如果能一次找准下一个要插入到队列中的作业的位置,则可避免队列中作业位置的移动,为算法节省不少时间,这是算法值得改进的地方。
为了给后继作业留下尽可能大的选择空间,在考虑作业i 时,将[0 、1 ] , [1 、2 ] , ⋯,[]i i d d ,1-中最大的空闲时间区间分配给作业i 。
通过使用不相交集合的UNION 与FIND 算法以及使用一个不同的方法来确定部分解的可行性,可以把JS 的计算时间由2()O n 降低到数量级相当接近于()O n 。
如果J 是作业的可行子集,那么可以使用下述规则来确定这些作业中的每一个作业的处理时间:若还没给作业i 分配处理时间,则分配给它时间片[]1,αα-,其中α应尽量取大且时间片[]1,αα-是空的。
此规则就是尽可能推迟对作业i 的处理。
于是,在将作业一个一个地装配到J 中时,就不必为接纳新作业而去移动J 中那些已分配了时间片的作业。
如果正被考虑的新作业不存在像上面那样定义的α,这个作业就不能计入J 。
例5.3 设n=5,(p1,…,p5)=(20,15,10,5,1),(d1,…,d5)=(2,2,1,3,3)。
最优解是J ={1,2,4}由于只有n 个作业且每个作业花费一个单位时间,因此只需考虑这样一些时间片[]1,,1i i i b -≤≤,其中{}{}min ,max j b n d =。
为简便起见,用i 来表示时间片[]1,i i -。
实现上述调度规则的一种方法是把这b 个期限值分成一些集合。
对于任一期限值i ,设i n 是使得i n i ≤的最大整数且是空的时间片。
为避免极端情况,引进一个虚构的期限值0和时间片[]1,0-。
当且仅当i j n n =,期限值i 和j 在同一个集合中,即所要处理的作业的期限值如果是i 或j ,则当前可分配的最接近的时间片是i n 。
优先级排序 模拟题
优先级排序模拟题在日常生活和工作中,我们经常会面临各种任务和事务,有些是紧急重要的,而有些则是次要的。
为了有效地处理和组织这些任务,我们需要根据它们的优先级进行排序。
本文将模拟介绍优先级排序的过程,并提供一些相关的参考内容。
首先,为了进行优先级排序,我们需要明确任务的重要性和紧迫性。
重要性指的是任务对于目标的贡献程度,而紧迫性则表示任务完成的时限。
将任务分为以下四个优先级:1. 紧急重要:对目标贡献大且时限紧迫的任务。
这些任务应被优先处理,以确保其按时完成。
例如,突发客户问题、关键项目截止日期等。
2. 重要但不紧急:对目标贡献大但时限相对较宽松的任务。
在处理了紧急重要任务后,应着手处理这些任务,以确保不会被拖延。
例如,重要会议准备、长期项目的规划等。
3. 紧急但不重要:对目标贡献较小但时限紧迫的任务。
这些任务可以被委托给他人或者推迟处理,以便集中精力处理更重要的任务。
例如,一些日常事务、他人的紧急需求等。
4. 不紧急不重要:对目标贡献较小且时限相对较宽松的任务。
这些任务可以被放置在较低的优先级,以便在处理其他任务后再处理。
例如,一些琐碎的日常活动、低优先级的会议等。
当面对多个任务时,我们可以使用以下方法进行优先级排序:1. Eisenhower决策矩阵:这个方法将任务分为四个象限,分别对应上述提到的四个优先级。
通过这个矩阵,我们可以清晰地看到每个任务的优先级,以便更好地安排时间和资源。
2. 时间管理工具:有许多时间管理工具可以帮助我们进行任务排序和计划。
例如,使用番茄工作法来集中精力处理紧急重要的任务,使用GTD(Getting Things Done)方法来管理任务清单等。
3. 优先级评估:当面对多个任务时,我们可以进行优先级评估,给每个任务一个分数来确定其优先级。
这个分数可以根据任务的重要性、紧迫性、困难度等因素来确定。
4. 时间预算:在进行优先级排序时,我们可以为每个任务设置一个预计完成时间。
带有限期的作业排序
带有限期的作业排序带有限期的作业排序问题的描述:带有期限的作业排序要解决的是操作系统中单机、无资源约束且每个作业可在等量的时间内完成的作业调度问题。
把这个问题形式化描述为:①要在一台机器上处理n个作业,每个作业可以在单位时间内完成②每个作业i都有一个期限值di,di>0③当作业在它规定的期限值前完成,就可以获得的效益pi,pi>0问题求解的目标是:问题的可行解是这n个作业的一个子集合J。
J中的每个作业都能在各自的截止期限前完成后,产生一个作业效益之和。
我们的目标就是找到一个子集J,J中的每个作业都能在各自的截止期限前完成,并且使得作业效益值的和最大。
这个作业的一个子集合J就是所求的最优解。
带有期限的作业排序的一个例子:例3.2 n=4,(p1,p2,p3,p4)=(100,10,15,20),(d1,d2,d3,d4)=(2,1,2,1)。
这个问题的最优解为第7个,所允许的处理顺序是:先处理作业4,在处理作业1。
在时间0开始处理作业4而在时间2完成对作业1的处理。
可行解处理顺序效益值 1 {1} 1 100 2 {2} 2 10 3 {3} 3 15 4 {4} 4 20 5 {1,2} 2,1 110 6 {1,3} 1,3或3,1 115 7 {1,4} 4,1 120 8 {2,3} 2,3 25 9 {3,4} 4,3 35带有期限的作业排序贪心算法度量标准的选取:我们的目标是作业效益值的和最大,因此首先把目标函数作为度量标准。
首先把作业按照它们的效益值作一个非增次序的排序。
以例3.2来说,作业根据效益值排序后为作业1、4、3、2。
求解时首先把作业1计入J,由于作业1的期限值是2,所以J={1}是一个可行解。
接下来计入作业4。
由于作业4的期限值是1而作业1的期限值是2,可以先完成作业4后再完成作业1,所以J={1, 4}是一个可行的解。
然后考虑作业3,但是作业3的期限值是2,计入J后就没有办法保证J中的每一个作业都在期限值内完成,因此计入作业3后不能构成一个可行解。
两类带时限的作业排序问题
两类带时限的作业排序问题第1题带时限的作业排序问题问题描述:设有⼀个单机系统、⽆其它资源限制且每个作业运⾏相等时间,不妨假定每个作业运⾏ 1 个单位时间。
现有 n 个作业,每个作业都有⼀个截⽌期限di>0,di 为整数。
如果作业能够在截⽌期限之内完成,可获得 pi>0 的收益。
问题要求得到⼀种作业调度⽅案,该⽅案给出作业的⼀个⼦集和该作业⼦集的⼀种排列,使得若按照这种排列次序调度作业运⾏,该⼦集中的每个作业都能如期完成,并且能够获得最⼤收益。
输⼊:第⼀⾏输⼊ n 的值,以下 n ⾏输⼊作业号 i,收益 pi,截⽌期限 di。
输出:n 个作业的⼀个最优⼦集。
⽰例:输⼊:41 100 22 10 13 15 24 27 11 4输出: 0 0 1 1第2题带时限的作业排序问题II问题描述:带时限的作业排序问题可描述为:设有 n 个作业和⼀台处理机,每个作业所需的处理时间、要求的时限和收益可⽤三元组(pi, di, ti),0<=i<n 表⽰,其中,作业 i 的所需时间为 ti,如果作业 i 能够在时限 di 内完成,将可收益 pi,求使得总收益最⼤的作业⼦集 J。
输⼊:第⼀⾏输⼊ n 的值;第⼆⾏输⼊ pi;第三⾏输⼊ di;第四⾏输⼊ ti (i=0,…,n-1 且作业已经按时限⾮减次序排列)。
输出:xi(⽤固定长度 n-元组 xi 表⽰,xi=0 或 1,i=0,…,n-1)。
⽰例:输⼊:45 36 101 12 31 1 1 2输出: 0 0 1 1第1题思路分析这题的思路⽐较明显,就是每次都选取作业收益最⼤的,并把它放在允许的最⼤的截⽌时间内完成,符合贪⼼算法的基本思想。
将输⼊的每个作业按收益从⼤到⼩进⾏排序,⽤⼀个数组vis表⽰某时刻是否已经有作业正在运⾏,vis[i]=1,表⽰时间i被占⽤。
然后从第1个作业开始往后搜索,将该作业安排到vis[d]时间运⾏,如果d已经有安排,将从d-1开始往前搜索,直到找到⼀个未被占⽤的时间点。
带期限的作业调度问题
带期限的作业调度问题2010-2011 第二学期08通信专业算法作业题目:给定一个带期限的作业排序问题, n=5, (p1,p2,p3,p4,p5)=(6,3,4,8,5), (t1,t2,t3,t4,t5)=(2,1,2,1,1), (d1,d2,d3,d4,d5)= (3,1,4,2,4), 应用FIFOBB求使总罚款数最小的可行作业集J, 要求:1)阐述c’(X)和u(X)的设计思路,U的初始值;2)针对解向量变长格式, 画出FIFOBB的生成的部分状态空间树, 按活节点生成顺序给节点编号,在各节点位置给出c’(X)和U的值,给每条边标记选择的作业编号;3)阐述c’(X)=U的处理方案, 可行解的判断方案;4)阐述你程序中的主要数据类型、数据变量和功能模块。
5)、编成并上机实现FIFOBB程序, 实现对不同作业排序问题实例的求解,问题实例的输入数据存储在case.txt文件中,其格式为:第一行问题规模(最多10个作业)第二行各作业的罚款数,数据项之间用一个空格分隔第三行各作业的截止期限,数据项之间用一个空格分隔第四行各作业所需的运行时间,数据项之间用一个空格分隔解:1、C(x)为成本估计函数,Pi是各个作业的成本。
U(x)是对应结点X的解的成本值。
在比较的时候可能出现C(x)=U(x),我们设一个较小的常数e,一句当前结点的截止期限与前面结点的运行时间总和比较,若大于,则结点可行,不大于,则不可行。
2.状态空间树:方框:椭圆表示结点;作业:1 2 3 4 5 六边形表示死结点。
作业:2 3 4 5 3 4 5 4 5 5作业:3 4 5 4 5 5 4 5 5 5作业:51 11 10 9 8 7 12 6 5 43 2 16 15 14 13 1922 23 24 26 25估计成本:最小上界: 17,1718,18 21, 21 13, 18 9, 22 6, 23 0,267,12 3, 16 0, 17 13, 13 15, 15 9,1410,15 6, 19 0, 20 12, 127, 7 6, 1114,1410,106, 1117 2721 20183.主要数据类型与变量int max// 罚款总数int cost;//罚款int time;//所用时间{int parent;//父亲结点int x;//表示节点所做的任务几Int U;//存放最小成本int c;//估计罚款}4.算法或程序模块int maycost(Elemt X) 功能:计算估计成本maycost函数int Mincost(int x[5],int y[5]) 功能:计算最小上界mincost成本void entergroup(int w,int E) 功能:活结点进队列int outgroup(int E) 功能:活结点出队列void BB(int T) 功能:在所有的结点中寻找最小成本四、测试1.方案建立一个文本文档case.txt与程序放在同一个文件目录下。
有期限的作业调度算法doc
有期限的作业调度算法一、典型算法贪心算法是以局部最优为原则,通过一系列选择来得到问题的一个最优解,它所做的每一个选择都是当前状态下某种意义上的最佳选择.贪心算法适合于解决这样的问题:局部的最优解能够导致最终结果的最优解。
“有限期作业安排问题”描述如下:有n个任务J1,J2,...,Jn,每个任务Ji都有一个完成期限di,若任务Ji在它的期限di内完成,则可以获利Ci(1[i[n);问如何安排使得总的收益最大(假设完成每一个任务所需时间均为一个单位时间).这个问题适合用贪心算法来解决,贪心算法的出发点是每一次都选择利润大的任务来完成以期得到最多的收益;但是对于本问题由于每一个任务都有一个完成的期限,因此在任务安排过程中除了考虑利润Ci外,还要考虑期限di.(一)算法描述1.假设用数组J存储任务,用数组C存储利润,用数组d存储期限,用数组P存储安排好的任务.按照利润从大到小的次序,调整任务的次序:对n个任务J1,J2,...,Jn进行调整,使其满足C1≥C2≥…≥Cn.2.将排序后的任务顺次插入输出数组P.A)任务J[1]排在P[1];B)若已经优先安排了k个任务,则它们满足d[P[i]] ≥i(1≤i≤k),即利润较高的k个任务能够在它们的期限内完成.那么,对于第k+1个任务J[k+1],显然C[k+1] ≤C[i](1≤i≤k);比较d[k+1]和d[P[k]]:a)若d[k+1]大于d[P[k]],那么将它排在第k+1位(P[k+1]←J[k+1]);b)若d[k+1]小于等于d[P[k]],那么,J[k]能否插入,需比较k和d[P[k]]而定:i)若k等于d[P[k]](其第k个任务已经排在可以满足的最迟时间),那么,因为Ck≥Ck+1,只好放弃任务J[k+1];ii)若k小于d[P[k]](表示第k个任务还有推后的余地):若d[k+1]=k,将第k个任务后移一位(P[k+1]←P[k]),将第k+1个任务排在第k位(P[k] ←J[k+1]).若d[k+1]<k,则继续比较任务J[k+1]与第k-1个任务,方法同上.C)重复B)直至处理完最后一个任务.3)输出P.(二)算法实现voidjob-arrangement(char*J[],intd[],intC[],intP[],intn){sort(C,J,d,n); /*按照降序调整数组C,同时对数组J!d作相应调整*/P[0]=0;d[0]=0;P[1]=1;k=1;for(i=2;i<=n;i++){r=k;while{(d[P[r]]>=d[i])&&d[P[r]]!=r}r--;if(d[P[r]]<d[i])for(h=k;h>r;h--) P[h+1]=P[h];k++;P[r+1]=i;}output(P,J,n)}(三)算法分析该算法在最坏情况下的时间复杂度是O(n²),在最好情况下的是O(n)二.利用UNION与FIND进行作业排序利用不相交集合的UNION与FIND算法以及使用一个不同的方法来确定部分解的可行性。
顺序分配法例题
顺序分配法例题【最新版】目录1.顺序分配法简介2.顺序分配法例题解析3.顺序分配法的应用场景与注意事项正文一、顺序分配法简介顺序分配法,是一种在项目管理中对任务进行时间分配和排序的方法。
其主要原理是根据任务之间的依赖关系,以及任务本身的耗时,按照一定的顺序进行分配,以确保项目能够按照既定的计划和目标顺利进行。
顺序分配法不仅能够帮助项目管理者清晰地了解项目进度,还能有效地提高团队的工作效率。
二、顺序分配法例题解析假设有一个项目,包含三个任务:A、B、C。
其中,任务 A 需要 2 小时完成,任务 B 需要 3 小时完成,任务 C 需要 1 小时完成。
而任务 B 必须在任务 A 完成后才能开始,任务 C 必须在任务 B 完成后才能开始。
那么,如何使用顺序分配法对这三个任务进行时间分配和排序呢?首先,我们需要根据任务之间的依赖关系,确定任务的顺序。
在本例中,任务 A 完成后,任务 B 才能开始;任务 B 完成后,任务 C 才能开始。
因此,任务的顺序应为 A-B-C。
接下来,我们需要根据任务的耗时,对任务进行时间分配。
根据任务的顺序,我们可以将任务 A 分配 2 小时,任务 B 分配 3 小时,任务 C 分配 1 小时。
这样,整个项目的耗时即为 2+3+1=6 小时。
三、顺序分配法的应用场景与注意事项顺序分配法适用于那些具有明显依赖关系的项目,例如,软件开发项目、工程项目等。
在实际应用中,需要注意以下几点:1.确定任务之间的依赖关系。
这是顺序分配法的基础,只有准确地确定任务之间的依赖关系,才能进行准确的时间分配和排序。
2.确定任务的耗时。
任务的耗时是进行时间分配的重要依据,应尽量准确。
3.保持任务顺序的灵活性。
在项目进行过程中,可能会出现意外情况,需要调整任务的顺序。
因此,在实际应用中,应保持任务顺序的灵活性,以应对可能出现的情况。
4.定期检查项目进度。
顺序分配法只是一种项目管理方法,不能保证项目一定能够按照既定的计划和目标进行。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include<iostream.h>
#include <stdio.h>
#include <malloc.h>
int FIND(int *parent,int i)
{//查找含有元素i的树根,使用压缩规则去压缩由i到根j的所有结点int j,k,t;
j=i;
while(parent[j]> 0) j=parent[j];//找根
k=i;
while(k!=j){//压缩由i到根j的结点
t=parent[k];
parent[k]=j;
k=t;
}
return j;
}
void UNION(int *parent,int i,int j)
{//使用加权规则合并根为i和j的两个集合
int x;
x=parent[i]+parent[j];
if(parent[i]> parent[j]){//i的结点少
parent[i]=j;
parent[j]=x;
}
else{//j的结点少
parent[j]=i;
parent[i]=x;
}
}
int MIN(int n,int m)
{//求n和m的最小值
if(n> m) return m;
else return n;
}
int FJS(int *D,int n,int b,int *J,int *Q)
{//找J(n)的最优解,并返回最优解的个数
int i,*F,*p,j,l,m,k;
F=(int *)malloc((b+1)*sizeof(int));
p=(int *)malloc((b+1)*sizeof(int));
for(i=0;i <=b;i++){//将树置初值
F[i]=i;
p[i]=-1;
}
k=0;//初始化J
for(i=1;i <=n;i++)
{//使用贪心规则
j=FIND(p,MIN(n,D[i]));
if(F[j]!=0)
{//选择作业i
k=k+1;
J[k]=i;
Q[F[j]]=i;
m=F[j];
l=FIND(p,F[j]-1);
UNION(p,l,j);
F[j]=F[l];
}
}
return k;//返回最优解的个数
}
int MAXMUM(int i,int j)
{//求i和j的最大值
if(i> j) return i;
else return j;
}
int MAX(int *D,int i, int j)
{//D(1:n)是含有n个元素数组,求出D(i,j)中的最大值并返回int max,mid,max1,max2;
if(i==j) max=D[i];
else
if(i==j-1)
if(D[i] <D[j]) max=D[j];
else max=D[i];
else{
mid=(i+j)/2;
max1=MAX(D,i,mid);
max2=MAX(D,mid+1,j);
max=MAXMUM(max1,max2);
}
return max;
}
void Insertionsort(int *D,int n)
{//将D中的元素按非增次序分类
int j,item,i;
D[0]=65525; //设置监视哨
for(j=2;j <=n;j++){
item=D[j];
i=j-1;
while(item> D[i]){
D[i+1]=D[i];
i=i-1;
}
D[i+1]=item;
}
}
int main()
{
int *D,*J,*Q,*p,n,b,i,k;
cout<<" 用贪心法解决带有限期的作业排序问题"<<endl; cout<<endl<<endl;
cout<< "请输入作业的数目: ";
cin>>n;
D=(int*)malloc((n+1)*sizeof(int));
p=(int*)malloc((n+1)*sizeof(int));
cout<<"请输入每个作业的效益值"<<endl;
for(i=1;i <=n;i++)
cin>>p[i];
Insertionsort(p,n);
cout<<"按效益值非增排序后各作业为: "<<endl;
cout<<"作业序号效益值"<<endl;
for(i=1;i <=n;i++)
cout<<" "<<i<<" "<<p[i]<<endl;
cout<< "请输入按效益值非增排序后各作业的截止时间: "<<endl;
for(i=1;i <=n;i++)
cin>>D[i];
b=MIN(n,MAX(D,1,n));
J=(int*)malloc((b+1)*sizeof(int));
Q=(int*)malloc((b+1)*sizeof(int));
for(i=1;i <=b;i++)
Q[i]=-1;
k=FJS(D,n,b,J,Q);
cout<< "-----------------------------本问题的最优解---------------------------------"<<endl; cout<<"作业序号"<<" "<< "效益值"<<endl;
for(i=1;i <=k;i++)
cout<<J[i]<<" "<<p[i]<<endl;
cout<< "-----------------------------各作业的执行次序-------------------------------"<<endl; cout<<"作业序号"<<" "<<"效益值"<<endl;
for(i=1;i <=b;i++)
if(Q[i]!=-1)
cout<<Q[i]<<" "<<p[i]<<endl;
return 0;
}。