带期限的作业调度问题的算法与实现
操作系统中常用作业调度算法的分析
操作系统中常用作业调度算法的分析操作系统是计算机系统中最重要的组成部分之一，它负责管理计算机的各种资源并提供各种服务。
作业调度是操作系统的一个重要功能，它负责决定哪个作业在什么时候被执行。
为了更好地实现作业调度，操作系统中常用的作业调度算法有先来先服务（FCFS）、最短作业优先（SJF）、优先级调度、高响应比优先（HRRN）和时间片轮转等。
本文将对这些常用的作业调度算法进行分析，以便读者更好地理解它们的原理和应用。
1. 先来先服务（FCFS）先来先服务（FCFS）是最简单最直接的作业调度算法，它按照作业到达的先后顺序进行调度。
当一个作业到达后，操作系统会将其加入就绪队列，然后按照队列的先后顺序执行。
FCFS算法的优点是实现简单，代码简洁，但它也存在着明显的缺点，比如平均等待时间较长，无法适应多种作业的需要等。
由于FCFS算法对作业的执行时间没有考虑，所以可能导致长作业等待时间过长的问题，这就是著名的长作业效应。
2. 最短作业优先（SJF）最短作业优先（SJF）算法是一种按作业执行时间长度优先的调度算法，它会优先调度执行时间最短的作业。
相比于FCFS算法，SJF算法能够有效地减少平均等待时间，并且不会出现长作业效应。
SJF算法也存在着一个问题，即无法预知作业的执行时间，如果有一个长作业一直未能执行完毕，那么其他短作业就会一直等待，这就是短作业等待时间过长的问题。
为了解决这个问题，可以使用抢占式SJF算法，即当有一个短作业到来时，可以立即中断当前正在执行的长作业，这样可以更加公平地分配资源。
3. 优先级调度优先级调度是一种根据作业的优先级来进行调度的算法，优先级通常可以由作业的属性或者其他额外的信息决定。
优先级高的作业先被执行，如果有多个作业优先级相同，那么可以使用FCFS或者SJF等其他算法来决定先后顺序。
优先级调度算法的优点是可以根据不同的需求进行灵活的调度，但是也存在一些问题，比如可能会导致低优先级作业长时间等待而无法执行的情况。
算法-带有期限的作业排序问题
姓名：
学号：
问题解析（对问题的分析、解题思路与解题方法）：
对当前正在考虑的作业，按限期大小采用一种“插入排序”的方式，尝试将其“插入”到一个按限期从小到大顺序构造的作业调度序列中，以此判断是否能够合并到当前部分解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.进一步了解操作系统中的进程调度机制。
二、实验环境本次实验使用的操作系统环境为Windows平台。
三、实验内容1.实现一个简单的作业调度算法，根据作业的重要性和执行时间进行优先级排序；2.设计一个作业队列，模拟一系列作业的到达和执行过程；3.根据作业调度算法，将作业分配给CPU执行，并统计作业的等待时间、完成时间等指标；4.进行多次实验，比较不同调度算法之间的性能差异。
四、实验步骤1.首先，设计一个作业类，包括作业的名称、重要性、到达时间和执行时间等属性；2.定义一个作业队列，用于存储到达的作业，并按照到达时间进行排序；3.实现一个简单的作业调度算法，根据作业的重要性和执行时间进行优先级排序；4.设计一个CPU类，用于执行作业队列中的作业，并记录作业的等待时间、完成时间等指标；5.模拟一系列作业的到达和执行过程，将作业调度给CPU执行，并记录相关指标；6.分别使用不同的调度算法进行多次实验，比较各自的性能差异。
五、实验结果与分析通过多次实验，得到了不同调度算法下的作业等待时间、完成时间等指标，并进行了比较。
结果发现，在作业执行时间相同时，按照作业的重要性进行优先级排序的算法，能够使得较重要的作业尽早执行，因而整体的作业等待时间和完成时间较短。
而对于作业执行时间不一致的情况，采用短作业优先算法，可以使作业平均等待时间较短，但在一些较长的作业上可能会存在饥饿现象。
综合考虑作业的重要性和执行时间，采用带权重的优先级队列算法可以获得较好的调度效果。
六、实验总结通过本次实验，我深入了解了作业调度的概念、原理和实现方式。
通过对比不同调度算法的性能差异，对于实际的作业调度过程具有一定的指导意义。
此外，通过实验设计和代码实现，我也提高了编程和分析问题的能力。
总体而言，本次实验使我对操作系统中的作业调度有了更为深刻的理解，并提高了我的实践能力。
有期限的作业调度算法doc
有期限的作业调度算法一、典型算法贪心算法是以局部最优为原则,通过一系列选择来得到问题的一个最优解,它所做的每一个选择都是当前状态下某种意义上的最佳选择.贪心算法适合于解决这样的问题:局部的最优解能够导致最终结果的最优解。
“有限期作业安排问题”描述如下:有n个任务每个任务Ji都有一个完成期限di,若任务Ji在它的期限di内完成，则可以获利Ci(l[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(1WiWk)，即利润较高的k个任务能够在它们的期限内完成•那么，对于第k+1个任务J[k+1],显然C[k+1]WC[i](1WiWk);比较d[k+1]和d[P[k]]:a)若d[k+1]大于d[P[k]],那么将它排在第k+1位(P[k+1]T[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)}(三)算法分析该算法在最坏情况下的时间复杂度是0(n?)，在最好情况下的是0(n)二.利用UNION与FIND进行作业排序利用不相交集合的UNION与FIND算法以及使用一个不同的方法来确定部分解的可行性。
时限调度算法给出的调度顺序
时限调度算法给出的调度顺序时限调度算法是一种常用的任务调度算法，它主要用于在有限的时间内，合理地安排多个任务的执行顺序，以提高系统的效率和性能。
本文将介绍时限调度算法的基本原理和常见的调度顺序。
一、先来了先服务（FCFS）调度顺序先来了先服务（First-Come-First-Served）调度顺序是最简单的一种调度算法，它按照任务到达的先后顺序进行调度。
当一个任务到达后，系统就立即执行它，直到任务结束或发生阻塞。
这种调度顺序的优点是简单易实现，但缺点是无法根据任务的重要程度和紧急程度进行优先级调度，容易导致低优先级任务长时间等待。
二、最短作业优先（SJF）调度顺序最短作业优先（Shortest-Job-First）调度顺序是根据任务的执行时间长度进行调度的算法。
当多个任务同时到达时，系统会选择执行时间最短的任务先执行。
这种调度顺序的优点是能够最大程度地减少平均等待时间，提高系统的响应速度。
然而，它也存在着一定的缺点，即可能导致长任务的饥饿问题，即长任务可能一直等待短任务执行完毕而得不到执行。
三、优先级调度顺序优先级调度顺序是根据任务的重要程度和紧急程度进行调度的一种算法。
每个任务都有一个优先级，优先级越高的任务越先执行。
这种调度顺序能够根据任务的紧急程度进行调度，保证重要任务得到及时处理。
然而，它也存在着可能导致低优先级任务长时间等待的问题，因此需要合理设置任务的优先级。
四、时间片轮转（RR）调度顺序时间片轮转（Round-Robin）调度顺序是一种基于时间片的调度算法，它将每个任务分配一个固定长度的时间片，当一个任务的时间片用完后，系统会将其放入等待队列，并执行下一个任务。
这种调度顺序能够公平地分配系统资源，避免某个任务长时间占用资源，但也可能导致任务的响应时间较长。
五、最早截止时间优先（EDF）调度顺序最早截止时间优先（Earliest-Deadline-First）调度顺序是根据任务的截止时间进行调度的一种算法。
作业调度问题的优化算法与实现
学号：***********毕业设计题目：作业调度问题的优化算法与实现作者宋梦杰届别2014届系别信息与通信工程专业通信工程指导教师李文彬职称讲师完成时间2014年5月15日摘要作业调度问题，实质是资源调度问题，已被证明是个NP-hard 完全问题，对资源调度的进一步研究具有重大的现实意义，已成为现今研究的热点。
本文在作业调度和算法设计的基础上，对带期限的作业调度问题，优先级问题，多工序多机器问题进行了研究分析，并且根据其特点进行设计仿真。
然后结合遗传算法，分析资源调度问题的特点，设计独特的交叉和变异方式，保证解的合法性。
验证了遗传算法在保证局部搜索速度的前提下还尽可能的保证全局搜索，避免陷入局部最优，提高了最优率。
关键词：调度；多级反馈队列算法；流水线调度；遗传算法IABSTRACTJob scheduling problem, in essence, resource scheduling problem, has proven to be an NP-hard problem completely, of great practical significance for further research resource scheduling has become a hot research today.On the basis of job scheduling and algorithm design, the problem of job scheduling with deadlines, priority issues, multi-process multi-machine problems were studied and analyzed, and design simulation according to their characteristics. Then combined with genetic algorithm to analyze the characteristics of resource scheduling problem, design a unique crossover and mutation methods to ensure the legitimacy of the solution. Verify that the genetic algorithm under the premise of guaranteed rate of local search is also possible to ensure global search, to avoid falling into local optimum and improve the optimal rate.Keywords: scheduling; multilevel feedback queue algorithm; pipeline scheduling;genetic algorithm目录摘要 (I)ABSTRACT ....................................................................................................................... I I 第一章绪论.. (1)1.1目的与意义 (1)1.2作业调度的现状 (1)1.3论文内容及结构 (2)第二章相关算法研究 (3)2.1问题描述 (3)2.2基于贪心算法的带期限的作业调度 (4)2.3分枝限界法 (5)2.4多级反馈队列算法 (6)2.5流水调度算法 (7)2.6遗传算法 (8)2.7本章小结 (10)第三章经典作业调度优化方法 (11)3.1带限期的作业调度问题 (11)3.1.1基于贪心算法的作业调度 (11)3.1.2基于分枝限界法的作业调度 (12)3.2多级反馈队列调度算法 (14)3.2.1多级反馈队列调度算法的描述 (14)3.2.2算法设计 (15)3.2.3仿真 (17)3.3流水线作业调度 (18)3.3.1问题描述与分析 (18)3.3.2求解过程 (18)3.3.3算法的设计 (20)3.3.4仿真 (20)3.4本章小结 (22)第四章基于遗传算法的作业调度优化方法 (23)4.1问题描述 (23)4.2算法分析 (23)4.2.1JSP调度问题数学模型 (23)4.2.2假设条件和分类 (24)4.3算法设计 (25)4.3.1遗传编码 (25)4.3.2适应度函数的确定 (25)4.3.3种群初始化 (25)4.3.4交叉 (26)4.3.5变异 (26)4.4仿真 (26)4.5 本章小结 (30)结论和展望 (31)参考文献 (32)致谢 (34)附件一 (35)附件二 (40)第一章绪论1.1目的与意义随着全球化市场压力、产品个性化压力、高技术压力与资源压力的日趋加重，企业以前的大规模生产方式已经无法满足如今客户的需要，多品种小批量的生产模式已经逐渐占领市场。
作业调度算法(先来先服务算法,短作业算法)
题目：作业调度算法班级：网络工程姓名：朱锦涛学号：E一、实验目的用代码实现页面调度算法，即先来先服务（FCFS）调度算法、短作业优先算法、高响应比优先调度算法。
通过代码的具体实现，加深对算法的核心的理解。
二、实验原理1.先来先服务（FCFS）调度算法FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行的时间的长短，从后备作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。
然后把它放入就绪队列。
2.短作业优先算法SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。
作业的长短是以作业所要求的运行时间来衡量的。
SJF算法可以分别用于作业和进程调度。
在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存。
3、高响应比优先调度算法高响应比优先调度算法则是既考虑了作业的等待时间，又考虑了作业的运行时间的算法，因此既照顾了短作业，又不致使长作业等待的时间过长，从而改善了处理机调度的性能。
如果我们引入一个动态优先级，即优先级是可以改变的令它随等待的时间的延长而增加，这将使长作业的优先级在等待期间不断地增加，等到足够的时间后，必然有机会获得处理机。
该优先级的变化规律可以描述为：优先权 = （等待时间 + 要求服务时间）/要求服务时间三、实验内容源程序：#include<>#include<>#include<>struct work{i nt id;i nt arrive_time;i nt work_time;i nt wait;f loat priority;typedef struct sjf_work{s truct work s_work; d = rand()%10;w[i].arrive_time = rand()%10;w[i].work_time = rand()%10+1;}f or(j=0;j<5;j++){printf("第%d个作业的编号是：%d\t",j+1,w[j].id);printf("第%d个作业到达时间：%d\t",j+1,w[j].arrive_time);printf("第%d个作业服务时间：%d\t",j+1,w[j].work_time);printf("\n");for(j=1;j<5;j++)for(k=0;k<5-j;k++){if(w[k].arrive_time > w[k+1].arrive_time) {temp = w[k];w[k] = w[k+1];w[k+1] = temp;}}printf("\n");w_finish_time[0] = w[0].arrive_time +w[0].work_time;for(j=0;j<5;j++){if(w_finish_time[j] < w[j+1].arrive_time){w_finish_time[j+1] = w[j+1].arrive_time + w[j+1].work_time;}elsew_finish_time[j+1] = w_finish_time[j] +w[j+1].work_time;}for(j=0;j<5;j++)w_rel_time[j] = w_finish_time[j] -w[j].arrive_time;for(j=0;j<5;j++){rel_time += w_rel_time[j];}for(j=0;j<5;j++){printf("第%d个系统执行的作业到达时间：%d ",j+1,w[j].arrive_time);printf("编号是：%d ",w[j].id);printf("服务时间是：%d ",w[j].work_time);printf("完成时间是：%d ",w_finish_time[j]);printf("周转时间是：%d ",w_rel_time[j]);printf("\n");}printf("平均周转时间：%f\n",rel_time/5); }void SJF(){i nt w_rel_time[10];i nt w_finish_time[10];f loat rel_time = 0;s rand(time(0));i nt i;i nt j = 0;P NODE pHead = (PNODE)malloc(sizeof(NODE));i f (NULL == pHead){printf("分配失败, 程序终止!\n");exit(-1);P NODE pTail = pHead;p Tail->pNext = NULL; 来先服务算法该算法严格按照各作业到达时间来为其分配进程和资源，实验的结果见截图，最后算出该算法五个作业的平均周转时间。
时限调度算法
7-18-16-时限调度算法时限调度算法（Deadline Scheduling Algorithm）是一种用于管理任务或作业执行顺序的算法，其中每个任务都有一个特定的截止时间（deadline）和执行时间（processing time）。
这些任务需要在给定的截止时间之前完成，否则可能会导致问题或不符合约定。
时限调度算法的目标是在满足截止时间限制的前提下，尽量提高任务的执行效率。
以下是几种常见的时限调度算法：1. 最早截止时间优先（Earliest Deadline First, EDF）：• EDF算法的思想是在每个时刻，选择截止时间最早的任务来执行。
•这意味着优先执行那些紧急的任务，以确保它们在截止时间之前完成。
• EDF算法通常用于实时系统，以确保关键任务按时执行。
2. 最早截止时间优先的变种（EDF-VD）：•这是EDF算法的一种变种，它考虑了任务的惩罚因子，以决定哪个任务应该优先执行。
•任务的惩罚因子反映了任务没有按时完成时可能产生的损失或惩罚。
• EDF-VD算法尝试最小化总惩罚。
3. 最大松弛度优先（Laxity Scheduling）：•在这种算法中，每个任务都有一个松弛度（laxity），它表示任务可以延迟多少时间而不会违反截止时间。
•选择具有最大松弛度的任务来执行，以确保截止时间内完成，并允许尽可能多的任务延迟。
4. 周期性调度算法（Periodic Scheduling）：•这类算法通常用于实时系统，其中任务具有周期性的执行要求。
•常见的周期性调度算法包括周期性率单调（Rate Monotonic Scheduling）和周期性优先级调度（Fixed Priority Scheduling）。
这些算法的选择取决于具体应用场景和任务要求。
时限调度算法通常用于嵌入式系统、实时操作系统和其他需要满足任务截止时间的应用程序中。
在选择算法时，需要考虑任务的特性、截止时间、执行时间和系统资源，以便找到最合适的调度策略。
一个任务调度问题-----算法导论
⼀个任务调度问题-----算法导论⼀、问题描述 在单处理器上具有期限和惩罚的单位时间任务调度问题。
⼆、算法原理 任务调度问题就是给定⼀个有穷单位时间任务的集合S，集合S中的每个任务都有⼀个截⽌期限d i和超时惩罚w i，需要找出集合S的⼀个调度，使得因任务误期所导致的总惩罚最⼩，这个调度也称为S的⼀个最优调度。
实现任务的最优调度主要就是利⽤贪⼼算法中拟阵的思想。
如果S是⼀个带期限的单位时间任务的集合，且I是所有独⽴的任务集构成的结合，则对应的系统M=（S，I）是⼀个拟阵。
利⽤拟阵解决任务调度问题的算法原理主要就是将最⼩化迟任务的惩罚之和问题转化为最⼤化早任务的惩罚之和的问题，也就是说在任务调度的时候优先选择当前任务序列中惩罚最⼤的任务。
这⾥，假设集合A存放任务的⼀个调度。
如果存在关于A中任务的⼀个调度，使得没有⼀个任务是迟的，称任务集合A是独⽴的。
实现该问题的贪⼼算法如下： A <- Ø Sort S[M] into monotonically decreasing order by w for each x∈S[M] do if AU{x} ∈ I[M] then A <- AU{x} 初始时A为空集，然后对S中的所有任务按惩罚⼤⼩降序排序，然后进⼊循环。
循环的过程中依次访问S的中所有任务，然后进⾏独⽴性检查，如果当前任务x加⼊集合A之后A依然是独⽴的，则将A置为AU{x}，否则检查下⼀个任务直到扫描结束，最后所得到的集合A即是⼀个最优⼦集，然后进⾏相应的调整得到最后的输出。
三、实验数据 （1）任务调度问题的输⼊： a) 任务的数量n，即表⽰当前任务集合S={a1,a2,a3……an}； b) n个任务的期限d1,d2,d3……dn，每个任务的di满⾜1≤ di ≤n，且任 务要求ai在di之前完成； c) n个任务的权（惩罚）w1,w2,w3……wn。
表⽰任务ai如果没在时间di 之前完成，则导致惩罚wi，如果任务在期限之前完成，则没有惩罚; 同时在本实验中，还会将每个wi值替换为max{w1,w2,w3……wn}-wi，并运⾏算法进⾏第⼆次实验，然后⽐较两次实验所得结果。
作业（进程）调度算法
作业（进程）调度算法
（1）先来先服务调度算法（FCFS）（作业、进程调度）：算法简单，但效率较低；有利于长作业，但对短作业不利，有利于CPU繁忙型作业，不利于I/O繁忙型作业。
（2）短作业优先调度算法（SJF）（作业）：运⾏时间短的作业优先执⾏，该算法对长作业不利，易造成“饥饿”问题，即长作业由于优先级低可能长期得不到处理。
（3）时间⽚轮转调度算法（进程调度）：
时间⽚的⼤⼩对系统性能影响很⼤，如果时间⽚⾜够⼤，以⾄于所有的进程都能在⼀个时间⽚内执⾏完毕，则退化为FCFS算法，如果时间⽚很⼩，那么处理机在进程间频繁切换，处理机真正⽤于运⾏⽤户进程的时间将减少。
时间⽚的长短由：系统的响应时间、就绪队列中的进程个数和系统的处理能⼒决定。
（4）优先级调度算法（作业、进程调度）：根据进程优先级决定运⾏的进程
（5）⾼响应⽐优先调度算法（作业调度）：响应⽐ = 1 + 作业等待时间/估计运⾏时间重点内容
（6）多级队列调度算法（进程调度）：对多个就绪队列设计不同的调度算法
（7）多级反馈队列调度算法：（UNIX调度⽤这个）。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告：作业调度引言：操作系统是计算机系统中最核心的软件之一，它负责管理计算机的资源，为用户提供良好的使用环境。
在操作系统中，作业调度是非常重要的一部分，它决定了计算机如何合理地分配和调度各个作业的执行顺序，以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法，将就绪队列中的作业按照一定的顺序分配给处理器，使得计算机系统能够充分利用资源，提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务（FCFS）调度算法FCFS调度算法是最简单的调度算法之一，它按照作业的到达顺序进行调度，先到达的作业先执行。
这种算法的优点是简单易实现，但是可能会导致长作业等待时间过长，造成资源浪费。
2. 最短作业优先（SJF）调度算法SJF调度算法是根据作业的执行时间来进行调度，执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间，提高系统的响应速度，但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度，优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级，但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片，每个作业在一个时间片内执行，时间片用完后，将处理器分配给下一个作业。
这种算法可以实现公平性，但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中，我们使用了不同的作业调度算法，并对其进行了性能测试。
测试结果显示，FCFS算法在平均等待时间方面表现较差，而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性，但是可能会导致长作业等待时间过长。
结论：作业调度是操作系统中的重要组成部分，合理的作业调度算法能够提高计算机系统的效率和性能。
作业调度算法-实验报告
作业调度算法模拟一、课题内容和要求常见的作业调度算法有先来先服务算法、最短作业优先算法、响应比优先调度算法。
(1)参考操作系统教材理解这3种算法。
(2)实现这3个算法。
(3)已知若干作业的到达时间和服务时间，用实现的算法计算对该组作业进行调度的平均周转时间Ttime和平均带权周转时间WTtime。
(4)作业的到达时间和服务时间可以存放在文本文件record.txt中。
(5)设计简单的交互界面，演示所设计的功能。
(可以使用MFC进行界面的设计) （6）可根据自己能力，在完成以上基本要求后，对程序功能进行适当扩充。
二、需求分析模拟实现作业调度算法，包括：FCFS（先来先服务算法）、SJF（短作业优先算法）、HRN（最高响应比优先算法）、HPF（基于优先数调度算法）。
先来先服务算法：按照各个作业进入系统（输入井）的自然次序来调度算法。
短作业优先算法：优先调度并处理短作业。
所谓的“短作业”并不是指物理作业长度短，而是指作业的运行时间短。
最高响应比优先算法：优先调度并处理响应比最高的作业。
三、概要设计函数中一些类：1、2、先来先服务：3、最短作业优先：4、最高响应比：四、详细设计1、程序代码MFC头文件a.h内容：const int defMaxJobNumber = 10; //作业数量的最大值class Time //时间类{public:int hour;int minute;};class Job//作业类{public:int ID; //作业编号Time enter; //进入时间int requesttime; //估计运行时间int priority; //优先数Time start; //开始时间Time end; //结束时间int Ttime; //周转时间double WTtime; //带权周转时间};class schedule //调度类{public:int size; //作业数Job *job; //作业数组int *r; //排序用数组int Differ(Time t1,Time t2) //求两个时刻间的时间差t2-t1{int borrow = (t2.minute<t1.minute) ? 1 : 0;return ((t2.hour-t1.hour-borrow)*60+(borrow*60+t2.minute-t1.minute));}public:schedule() //构造函数{size = 0;job = new Job[defMaxJobNumber];r = new int[defMaxJobNumber-1];}void readFile() //从文件读信息{ifstream txtfile;txtfile.open("record.txt");int i = 0;int entertime;while(!txtfile.eof()){txtfile>>job[i].ID>>entertime>>job[i].requesttime>>job[i].priority;job[i].enter.hour = entertime / 100; //取小时job[i].enter.minute = entertime % 100; //取分钟i++;size++;}txtfile.close();}void FCFS()//先来先服务(First Come First Serve){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime;job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime;for(int i=1;i<size;i++){job[i].start = job[i-1].end;hour = job[i].requesttime / 60;minute = job[i].requesttime % 60;job[i].end.minute = (job[i].start.minute + minute) % 60;carry = (job[i].start.minute + minute) / 60;job[i].end.hour = job[i].start.hour + hour + carry;job[i].Ttime = Differ(job[i].enter,job[i].end); //周转时间job[i].WTtime = ((double)job[i].Ttime) / job[i].requesttime; //带权周转时间}}void SJF()//短作业优先(Shortest Job First){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60的商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime; //周转时间job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; //带权周转时间for(int i=1;i<size;i++)r[i] = i;for(i=1;i<size-1;i++) //按照作业运行时间从低到高排序{int index = i;for(int j=i+1;j<size;j++)if(job[r[j]].requesttime<job[r[index]].requesttime)index = j;if(index!=i){int w = r[i];r[i] = r[index];r[index] = w;}}int dest=0;for(i=1;i<size;i++) //按排序后的作业序继续执行{int index = r[i];job[index].start = job[dest].end;hour = job[index].requesttime / 60;minute = job[index].requesttime % 60;job[index].end.minute = (job[index].start.minute + minute) % 60;carry = (job[index].start.minute + minute) / 60;job[index].end.hour = job[index].start.hour + hour + carry;job[index].Ttime = Differ(job[index].enter,job[index].end);job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime;dest = index;}}void HRN() //最高响应比优先(Highest Response_ratio Next){int hour,minute,carry;job[0].start = job[0].enter;hour = job[0].requesttime / 60;minute = job[0].requesttime % 60;job[0].end.minute = (job[0].start.minute + minute) % 60;carry = (job[0].start.minute + minute) / 60; //carry是分钟累积超过60的商job[0].end.hour = job[0].start.hour + hour + carry;job[0].Ttime = job[0].requesttime; //周转时间job[0].WTtime = ((double)job[0].Ttime) / job[0].requesttime; 带权周转时间int dest=0;for(int i=1;i<size;i++)r[i] = i;for(i=1;i<size;i++){int index = i;for(int j=i+1;j<size;j++) //按照响应比从大到小排序if(((double)Differ(job[r[j]].enter,job[dest].end))/job[r[j]].requesttime>((double)Differ(job[r[index]].enter,job[dest].end))/job[r[index]].requesttime)//响应比=作业周转时间/作业处理时间index = j;if(index!=i){int w = r[i];r[i] = r[index];r[index] = w;}//按排序后的作业序继续执行index = r[i];job[index].start = job[dest].end;hour = job[index].requesttime / 60;minute = job[index].requesttime % 60;job[index].end.minute = (job[index].start.minute + minute) % 60;carry = (job[index].start.minute + minute) / 60;job[index].end.hour = job[index].start.hour + hour + carry;job[index].Ttime = Differ(job[index].enter,job[index].end);job[index].WTtime = ((double)job[index].Ttime) / job[index].requesttime;dest = index;}}};五、测试数据及其结果分析从文本文件中读取数据（书上的例子）：1 800 120 22 850 50 33 900 10 14 950 20 4输出的平均周转时间、平均带权周转时间结果正确。
带期限的作业调度算法[整理]
![带期限的作业调度算法[整理]](https://img.taocdn.com/s3/m/b3b49612cd1755270722192e453610661ed95a33.png)
算法设计思想：如果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个字节。
带期限的作业调度问题的算法与实现
2010-2011 第二学期08通信专业期末考查带期限的作业调度问题的算法与实现班级08通信一班学号14082300943姓名张博成绩分一、设计目的1.掌握分枝-限界法算法的解题的基本思想和设计方法;2.理解分枝-限界法算法中的限界函数应遵循正确，准确，高效的设计原则;3.掌握先进先出分枝-限界算法思想（FIFOBB）解决带期限作业调度问题。
二、设计内容1.任务描述给定一个带期限的作业排序问题, n=5, (p1,p2,p3,p4,p5)=(6,3,4,8,5),(t1,t2,t3,t4,t5)=(2,1,2,1,1), (d 1,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个作业）第二行各作业的罚款数，数据项之间用一个空格分隔第三行各作业的截止期限，数据项之间用一个空格分隔第四行各作业所需的运行时间，数据项之间用一个空格分隔例如：45 106 31 32 11 2 1 1从屏幕直接输出最优作业集的序号，数据项之间用逗号分隔。
三、设计思路1.几个关键数据的处理1)c'的设计思路是总共结点总成本减去当前结点的成本再减去其最小成本上界的成本。
2)在处理计算最小成本上界时，我利用了一个数组binGroup2，给它初始化为{1,1,1,1,1}，设计每个结点结构体都有一个这样的数组，每个结点做了那个作业就把对应作业的二进制数制为0；在计算最小估计成本上界时就将这个数组乘以结点成本数组，然后循环求和。
作业调度 算法设计
作业调度算法设计作业调度算法设计作业调度是在操作系统中的一个重要问题，涉及到多个任务的执行顺序和优先级，以及如何合理地分配资源和时间片，以提高系统的效率和响应速度。
本文将探讨几种常见的作业调度算法设计。
1. 先来先服务（FCFS）调度算法：先来先服务是最简单的作业调度算法，按照作业到达的先后顺序进行调度。
当一个作业到达后，它将占用CPU直到完成，然后才会调度下一个作业。
这种算法实现容易，但是有可能引发"饥饿"的问题，即长作业抢占了CPU资源，导致短作业等待时间过长。
2. 最短作业优先（SJF）调度算法：最短作业优先调度算法是根据作业的执行时间进行调度。
当一个作业到达后，调度器将选择执行时间最短的作业先运行。
这种算法可以最大程度地减少作业的等待时间和周转时间，但是需要预先知道每个作业的执行时间，而实际情况下往往无法准确估计。
3. 优先级调度算法：优先级调度算法给每个作业分配一个优先级，根据优先级的高低进行调度。
优先级可以根据作业类型、作业重要性或其他标准来确定。
这种算法能够充分考虑作业的紧迫性和重要性，但是可能导致优先级较低的作业长时间等待，产生"饥饿"问题。
4. 时间片轮转调度算法：时间片轮转调度算法是一种基于时间片的多道程序设计调度算法。
每个作业被分配一个时间片，当时间片耗尽后，作业会被暂停并切换到下一个作业执行。
这种算法实现简单，能够实现公平调度和响应时间较好，但是对于长时间运行的作业不太友好。
综上所述，作业调度算法的选择可以根据具体需求和系统情况来确定。
FCFS 适用于简单需求，SJF适用于作业执行时间已知的情况，优先级调度适用于根据作业的重要性进行调度，时间片轮转算法适用于多道程序设计的环境。
根据实际情况选择合适的作业调度算法，能够提高系统的效率和响应速度。
高性能计算中的任务调度算法与实现原理
高性能计算中的任务调度算法与实现原理任务调度是高性能计算中的重要组成部分，它负责将待执行的任务分配给计算节点，合理地利用计算资源，提高计算系统的效率和性能。
本文将介绍高性能计算中常用的任务调度算法和实现原理。
一、任务调度算法1. 静态调度算法静态调度算法是在计算任务开始执行之前就确定了任务在计算资源中的执行顺序。
其中，较为常见的静态调度算法包括：- 先来先服务（First-Come-First-Served，FCFS）算法：按任务到达时间的先后顺序进行调度，即先到先服务。
- 最短作业优先（Shortest Job First，SJF）算法：根据任务所需的计算时间进行排序，优先调度执行时间最短的任务。
- 静态优先级算法：为每个任务分配一个优先级，根据优先级将任务排序并进行调度。
2. 动态调度算法动态调度算法通过实时监测计算系统中的运行情况，根据具体情况动态地对任务进行调度。
常见的动态调度算法包括：- 最小可用计算节点（Minimum Available Nodes，MAN）算法：选择可用计算节点最少的节点执行任务。
- 最大可用计算节点（Maximum Available Nodes，MAX）算法：选择可用计算节点最多的节点执行任务。
- 最长等待时间（Longest Waiting Time，LWT）算法：选择等待时间最长的任务进行调度。
二、任务调度实现原理1. 任务调度器任务调度器是高性能计算系统中实现任务调度的核心组件。
它负责监控计算节点的状态、维护任务队列、分配任务，并与计算节点进行通信。
任务调度器的实现原理通常包括以下几个方面：- 资源管理：任务调度器通过监控计算节点的状态，维护一个资源池，记录计算节点的可用性、计算能力等信息，确保任务分配到合适的计算节点上。
- 任务调度策略：任务调度器根据任务的属性和系统的状态，选择适合的调度策略进行任务调度。
例如，根据任务的优先级、执行时间等属性进行调度决策。
带期限的作业排序问题
带期限的作业排序问题(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();}. .。
作业调度算法C++实现
学号： 姓名： 班级： 实验时间： 2011-10-10 实验编号002 实验名称 作业调度算法 实验目的和要求通过对作业调度算法的模拟加深对作业概念和作业调度算法的理解实验内容 （1） 模拟FCFS 算法实现作业调度 （2） 模拟短作业优先算法实现作业调度模拟最高相应比优先算法实现作业调度一、 实验题目输入：作业流文件，其中存储的是一系列要执行的作业，每个作业包括三个数据项：作业号、作业进入系统的时间（用一小数表示，如10：10，表示成10.10）、估计执行时间（单位小时，以十进制表示）参数用空格隔开，下面是示例：1 8.00 0.52 8.15 0.33 8.30 0.254 8.35 0.205 8.45 0.156 9.00 0.107 9.20 0.05其中调度时刻为最后一个作业到达系统的时间！输出：作业号 进入内存的时间，每行输出一个作业信息。
并输出每一种调度算法的平均周转时间和平均带权周转时间。
二、 算法设计思路首先用一个switch 函数做界面选择进入哪一种算法。
用一个内来定义作业float s;//提交时间float j;//执行时间float k;//开始时间float w;//完成时间float z;//周转时间float d;//带权周转时间1， 先来先服务，首先计算第一个作业的完成时间，周转时间，带权周转时间。
再用for 循环来计算剩下每一个作业的完成时间，周转时间，带权周转时间。
然后再算出平均周转时间和平均带权周转时间。
2， 短作业有优先，首先计算第一个作业的完成时间，周转时间，带权周转时间。
再用来计算其他作业的。
其中在for 循环中嵌套while 函数，在每一次计算前判断处于等待状态计算机操作系统 实验报告的作业个数，然后按执行时间，从短到长排序，将排在第一个的作业计算。
以此类推。
3．响应比，与短作业优先类似，只是在排序前，循环计算一次响应比，用一个数组来存放响应比，然后按照优先比从小到大排序，然后计算。
作业调度实验报告
作业调度实验报告1. 实验目的通过本次实验，使学生了解作业调度算法的基本原理和实现方法，掌握作业调度的实际应用，提高计算机系统的作业吞吐量和系统效率。
2. 实验环境•操作系统：Linux•编程语言：Python•实验工具：CPU模拟器3. 实验原理作业调度是操作系统中的一个重要环节，主要负责将用户提交的作业按照一定的策略分配到CPU上执行。
作业调度的主要目标是提高CPU的利用率，缩短作业的平均等待时间，提高系统的吞吐量。
常用的作业调度算法有先来先服务（FCFS）、短作业优先（SJF）、最短剩余时间优先（SRT）等。
4. 实验内容本次实验主要分为两个部分：一是实现作业调度算法，二是对不同算法进行性能分析。
4.1 作业调度算法实现以先来先服务（FCFS）算法为例，实现作业调度如下：```pythonclass Job:def __init__(self, job_id, arrival_time, execute_time):self.job_id = job_idself.arrival_time = arrival_timeself.execute_time = execute_timeclass JobScheduler:def __init__(self):self.jobs = []def add_job(self, job):self.jobs.append(job)def schedule(self):start_time = 0finish_time = 0for job in self.jobs:if job.arrival_time >= start_time:start_time = job.arrival_timefinish_time = start_time + job.execute_timeprint(f"Job {job.job_id} arrives at {start_time} and finishes a t {finish_time}")start_time = finish_timeif name== “main”:scheduler = JobScheduler()scheduler.add_job(Job(1, 0, 5))scheduler.add_job(Job(2, 1, 3))scheduler.add_job(Job(3, 3, 8))scheduler.schedule()4.2 性能分析通过对不同作业调度算法的模拟运行，分析其性能指标，如平均等待时间、平均响应时间、吞吐量等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
2010-2011 第二学期08通信专业期末考查带期限的作业调度问题的算法与实现班级08通信一班学号14082300943姓名张博成绩分一、设计目的1.掌握分枝-限界法算法的解题的基本思想和设计方法;2.理解分枝-限界法算法中的限界函数应遵循正确，准确，高效的设计原则;3.掌握先进先出分枝-限界算法思想（FIFOBB）解决带期限作业调度问题。
二、设计内容1.任务描述给定一个带期限的作业排序问题, n=5, (p1,p2,p3,p4,p5)=(6,3,4,8,5),(t1,t2,t3,t4,t5)=(2,1,2,1,1), (d 1,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个作业）第二行各作业的罚款数，数据项之间用一个空格分隔第三行各作业的截止期限，数据项之间用一个空格分隔第四行各作业所需的运行时间，数据项之间用一个空格分隔例如：45 106 31 32 11 2 1 1从屏幕直接输出最优作业集的序号，数据项之间用逗号分隔。
三、设计思路1.几个关键数据的处理1)c'的设计思路是总共结点总成本减去当前结点的成本再减去其最小成本上界的成本。
2)在处理计算最小成本上界时，我利用了一个数组binGroup2，给它初始化为{1,1,1,1,1}，设计每个结点结构体都有一个这样的数组，每个结点做了那个作业就把对应作业的二进制数制为0；在计算最小估计成本上界时就将这个数组乘以结点成本数组，然后循环求和。
3)c’(X)=U的处理方案：U取初值一个很大的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 1615 14 13 1922 23 24 26 25估计成本： 最小上界： 17,1718,18 21， 21 13，189，22 6， 23 0，267,12 3， 16 0， 17 13，1315， 15 9,1410,15 6, 19 0，20 12，127， 7 6, 1114，1410，106, 1117 2721 20183.主要数据类型与变量Int max;//罚款总数int cost[5]={6,3,4,8,5};//罚款int timeconsumer[5]={2,1,2,1,1};//所用时间int declitime[5]={3,1,4,2,4};//截止期限#define e 0.1Int U;//存放最小成本typedef struct aa{int parent;//父亲结点int x;//表示节点所做的任务几int binGroup1[4]={0,0,0,0,0};//记录做了的作业，把做了的作业记为1int binGroup2[5]={1,1,1,1,1};//记录没有做的作业，把做了的作业记为0int time;//记录耗时总和int maycost;//估计成本float mincost;//最小成本上界} ELEM;//节点当前任务，日期，估计成本，最小上界成本ELEM Node[N];//存放活结点数组4.算法或程序模块int maycost(Elemt X) 功能：计算估计成本maycost函数int Mincost(int x[5],int y[5]) 功能：计算最小上界mincost成本，即二进制数组2乘以成本数组int comparetime(int x[5],int y[5],int z[5]) 功能:计算总耗时间与最大截止期限做比较void entergroup(int w,int E) 功能：活结点进队列int outgroup(int E) 功能：活结点出队列void BB(int T) 功能：在所有的结点中寻找最小成本四、测试1.方案建立一个文本文档case.txt与程序放在同一个文件目录下。
在里面写入：45 106 31 32 11 2 1 12.结果理论结果是作业1,4,5，作用最小罚款数是7。
五、讨论与总结讨论1.在处理计算最小成本上界时，我利用了一个数组binGroup2，给它初始化为{1,1,1,1,1}，设计每个结点结构体都有一个这样的数组，每个结点做了那个作业就把对应作业的二进制数制为0；在计算最小估计成本上界时就将这个数组乘以结点成本数组，然后循环求和。
2.判断当前结点是否是解结点时，在比较当前结点总用时间与已做结点中的最大结点时间期限时，我也利用了上面讲到的数值binGroup1，处理方法是类似的。
若当前结点总用时间小于已做结点中的最大结点时间期限，则该结点不是解结点，反之则为解结点。
3.活结的进站，与出站，我同样是利用了数组，但是定义了两个标号。
x1指向了活结点数组开头，x2指向了活结点数组末尾。
活结点进站是x2加1，出站是x1加1，当x1=x2时候结点就出站完毕。
总结通过此次期末课程设计，我对分枝限界算法比书本上的认识有了更加深刻的理解。
本课程设计中在寻找最小罚款值时，定义了一个估计成本和最小成本上界，而答案成本就在它们中间。
是的，这样的做法，大大提高了程序的效率，减少的程序的盲目性。
其中，通过比较估计成本来判断结点是否可以进活结点队列，同时在队列中的结点又可以通过比较结点的最小成本上界来判断该节点是否需要继续执行下去。
在深刻体会到分枝限界算法的优越性的同时，在自己动手的程序设计中，我锻炼了自己的程序思维，通过上面所讲的利用数字处理问题的思路中，我明白实现一个程序的路子是不同的，假如直直的走不同，我们就可以在其它的角度去思考解决的办法。
当然编程时耐人的事，调试程序的时候有可能会把一个人的耐心磨掉。
因此，我们编程的时候应该要带着兴趣，带着不达目的誓不罢休的学习态度。
当我们全心全意的投入到我们的程序学习中，我们会大收获的。
不信的话，你可以试试！附：程序模块的源代码#include <stdio.h>#define N 100#define NUll 0x7fffffff#define max 26int cost[5]={6,3,4,8,5};//罚款int timeconsumer[5]={2,1,2,1,1};//所用时间int declitime[5]={3,1,4,2,4};//截止期限#define e 0.1;int E,Z,U,ans,x1=0,x2=0;typedef struct{ int parent;int x;//表示节点所做的任务几int binGroup1[4]={0,0,0,0,0};//记录做了的作业，把做了的作业记为1int binGroup2[5]={1,1,1,1,1};//记录没有做的作业，把做了的作业记为0int time;//记录耗时总和int maycost;//估计成本float mincost;//最小成本上界}ELEM;//节点当前任务，日期，估计成本，最小上界成本ELEM Node[N];int Maycost(Elemt X){if(!isOK(X)) return NULL;maycost=max-cost[X.x]-X.mincost;}int Mincost(int x[5],int y[5])//计算最小上界mincost成本，即二进制数组2乘以成本数组{int i,t=0; for(i=0;i<5;i++) t=t+x[i]*y[i]; return t;}int comparetime(int x[5],int y[5],int z[5])//计算总耗时间与最大截止期限做比较{int a,i,t=0,;for(i=0;i<5;t++) t=t+x[i]*y[i];//求出已经做的作业的总用时间for(i=0;i<5;i++) z[i]=z[i]*x[i];//把已经做了的作业显示出来，没有做的为0a=z[0];for(i=0;i<4;i++) if(a<z[i+1]) a=z[i+1];//找出已经做的作业的最大截止期限if(t<=a) return 1;else return 0;}void entergroup(int w,int E)//活结点进队列{x1++; Node[x1].x=w;Node[x1].binGroup1[5]=Node[E].binGroup1[5];Node[x1].binGroup2[5]=Node[E].binGroup2[5];Node[x1].time=Node[E].time;Node[x1].maycost=Node[E].maycost;Node[x1].mincost=Node[E].cost;}int outgroup(int E)//活结点出队列{x2++;E=x2;return E;}void BB(int T){E=T;Z=comparetime(timeconsumer[5],Node[E].binGroup1[5],declitime[5])if(Z=0){if(Node[E].maycost>(Node.mincost[E]+e))U=Node.mincost+e;elseU=Node.maycost;ans=T;}else{U=Node.mincost+e;ans=NUll;}x1=0;x2=0;//指向链表的标号for(i=Node[E].x+1;Node[E].x+1<5;(Node[E].x+1)++)//求解当前{ Node.binGroup1[Node[E].x]=1;Node.binGroup2[Node[E].x]=0;Node.time=Node.time+timeconsumer[Node[E].x];Node.maycost=Maycost(E);Node.mincost=Mincost(cost[5],Node.binGroup2[5]);}while(1){for(i=Node[E].x+1;Node[E].x+1<5;i++)if(Node.maycost<U){entgroup(Node[E].x,E);Node[i].parent=E;Z=comparetime(timeconsumer[5],Node[i].binGroup1[5],declitime[5]);if((Z=0)&&(Node[i].maycost<U)){if(Node[i].maycost>(Node[i].mincost+e))U=Node.mincost;else U=Node.maycost;ans=i;}else if((Node[i].mincost+e)<U)U=(Node[i].mincost+e);}while(1){if(x1=x2) printf("最小罚款数为=%d\n",U);while(ans!=0) { printf("%d ",ans);E=E.parent; return;}else outgroup(E);if(Node(E).maycost<U) break;} }void main(){Node[0]={{0},{0},{0,0,0,0,0},{1,1,1,1,1},{0},{0},{26}};//结点初始化freopen("case.txt","r",stdin);scanf("%d",&n);U=0;for(i=1;i<=n;i++){scanf("%d", &cost[i]);U +=p[i];}for(i=1;i<=n;i++)scanf("%d",&timeconsumer[i]);for(i = 1; i <= n;i++)scanf("%d",&declitime[i]);BB(0);}。