一个更快的带有期限的作业排序问题
#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;
}。
算法-带有期限的作业排序问题
姓名：
学号：
问题解析（对问题的分析、解题思路与解题方法）：
对当前正在考虑的作业，按限期大小采用一种“插入排序”的方式，尝试将其“插入”到一个按限期从小到大顺序构造的作业调度序列中，以此判断是否能够合并到当前部分解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)不为０then 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函数的逆函数。
）；它用于Ｆ和Ｐ的空间至多为２n个字节。
贪心法-带有限期的作业排序
贪⼼法-带有限期的作业排序问题描述–假定在⼀台机器上处理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.心得体会课程设计结束了，在这次的课程设计中不仅检验了我所学习的知识，也培养了我如何去做一件事情，又如何完成一件事情的能力。