带期限的作业调度问题的算法与实现
操作系统中常用作业调度算法的分析
操作系统中常用作业调度算法的分析操作系统是计算机系统中最重要的组成部分之一，它负责管理计算机的各种资源并提供各种服务。
作业调度是操作系统的一个重要功能，它负责决定哪个作业在什么时候被执行。
为了更好地实现作业调度，操作系统中常用的作业调度算法有先来先服务（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）。
这些算法的选择取决于具体应用场景和任务要求。
时限调度算法通常用于嵌入式系统、实时操作系统和其他需要满足任务截止时间的应用程序中。
在选择算法时，需要考虑任务的特性、截止时间、执行时间和系统资源，以便找到最合适的调度策略。
- 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);}。