作业调度贪心算法
软件算法设计
实验报告
题目：作业调度问题
院(系)：计算机科学与工程
专业：
班级：
学生：
学号：
2015年11 月
问题描述：
n个作业{1，2，…，n}要在由n台机器M1,...,Mn完成加工作业调度问题,要求确定这n个作业的最优加工顺序，使得从第一个作业在机器，到最后一个作业在机器上加工完成所需的时间最少。
算法设计：
贪心算法思想：
1.贪心选择性质：
所谓贪心选择性质是指应用同一规则f,将原问题变为一个相似的。但规模更小的子问题，而后的每一步都是当前看似最佳的选择。这种选择依赖于已做出的选择，但不依赖于未作出的选择。从全局来看，运用贪心策略解决的问题在程序中无回溯过程。
2.局部最优解：
我们通过特点2向大家介绍了贪心策略的数学描述。由于运用贪心策略解题在每一步都取得了最优解，但能够保证局部最优解的不一定是贪心算法。设7个独立作业{1,2,3,4,5,6,7}由3台机器M1，M2和M3加工处理。各作业所需的处理时间分别为{2,14,4,16,6,5,3}。按算法greedy产生的作业调度如下图所示，所需的加工时间为17。
算法实现:
1.运行环境：
Myeclipse 8.5 java project
2.源代码：
//基于最小堆的贪心算法解多机调度问题,
//heapsort on minheap
import java.io.*;
class MinHeap
{ //Min-heap impmentation
static jobNode[] Heap; //Pointer to the heap array
static int size; //Maximum size of the heap
static int n; //Number of intents now in heapheapsoet
public MinHeap(jobNode[] h,int num,int max)//constructor
{ Heap=h;n=num;size=max;buildheap();}
public int heapsize()//return current size of the heap
{ return n;}
public static boolean isLeaf(int pos)//true if pos is a leaf position
{ return(pos>=n/2)&&(pos public static void Assert_notFalse(boolean p,String q) {if(!p)System.out.println((String)q);} public static int key( int [] q,int p) { return q[p];} //return position for left child of pos public static int leftchild(int pos) { Assert_notFalse(pos return 2*pos+1; } //return position for right child of pos public static int rightchild(int pos) {Assert_notFalse(pos<(n-1)/2,"position has no right child"); return 2*pos+2; } public static int parent(int pos)//return position for parent {Assert_notFalse(pos>0,"position has no parent"); return (pos-1)/2; } public static void buildheap() //Heapify contents of Heap { for(int i=n/2-1;i>=0;i--)siftdown(i);} public static void swap(jobNode[] q,int i,int j) { jobNode temp; temp=q[i];q[i]=q[j];q[j]=temp;} private static void siftdown(int pos) //put intent in itscorrent place {Assert_notFalse((pos>=0) && (pos while(! isLeaf(pos)) { int j=leftchild(pos); if(j<(n-1)&&Heap[j].key()>Heap[j+1].key()) j++;// j is now index of child with greater value if(Heap[pos].key()<=Heap[j].key()) return;// Done swap(Heap,pos,j); pos=j; } //Move down } public static void insert(jobNode val) //Insert value into heap { Assert_notFalse(n int curr=n++; Heap[curr]=val; //start t end of heap //Now sift up until curr's parent's key while(curr!=0 && Heap[curr].key() { swap(Heap,curr,parent(curr)); curr=parent(curr); } } public static jobNode removemin() //remove minimum value { Assert_notFalse(n>0,"Removing from empty heap "); swap(Heap,0,--n);//swap minimum with last value if(n!=0) //Not on last intent siftdown(0); //Put new heap root val in corrent place return Heap[n]; } //Remove intent at specified position public static jobNode remove(int pos) { Assert_notFalse((pos>0)&&(pos swap(Heap,pos,--n);//swap with last value if(n!=0) //Not on last intent siftdown(pos);//put new heap root val in corrent place return Heap[n]; } public static void outMinHeap() { for(int i=0;i<=n-1;i++) System.out.print(Heap[i].time+" "); System.out.println(); } static void heapsort() //heapsort { System.out.println("建最小堆之后排序"); for(int i=1;i System.out.print(removemin()+" "); System.out.println( ); //removemin places min value at end of heap } }// class MinHeap class jobNode implements Comparable { int id; int time; jobNode(int i,int tt) { id=i; time=tt; } public int compareTo(Object x) { int xt=((jobNode)x).time; if(time if(time==xt)return 0; return 1; } public int key() { return time;} } public class Fac4_7_1 { public static void mergeSort(jobNode[] a,int left,int right) { jobNode []b=new jobNode[a.length]; if(left int i=(left+right)/2; mergeSort(a,left,i); mergeSort(a,i+1,right); merge(a,b,left,i,right); copy(a,b,left,right); } } public static void copy(jobNode[] a,jobNode[] b,int i,int j) { for(int k=i;k<=j;k++) a[k]=b[k]; } public static void merge(jobNode [] c,jobNode [] d,int l,int m,int r) {//合并c[l:m]和c[m+1:r]到d[l:m] int i=l, j=m+1, k=l; while((i<=m)&&(j<=r)) if(c[i].time-c[j].time>0) d[k++]=c[i++]; else d[k++]=c[j++]; if(i>m) for(int q=j;q<=r;q++) d[k++]=c[q]; else for(int q=i;q<=m;q++) d[k++]=c[q]; } public static void main(String args[]) { int m1=0,m=3; int a[]={2,14,4,16,6,5,3}; int n1=a.length-1; int sum=0; if(n1 { for(int i=0;i<=n1;i++) if(sum System.out.println("为每个作业分配一台机器,最长时间为"); System.out.println(sum); } else { jobNode []d=new jobNode[n1+1]; for(int i=0;i<=n1;i++) d[i]=new jobNode(i,a[i]); mergeSort(d,m1,n1); MinHeap abc=new MinHeap(d,m1,3); for(int i=m1;i { jobNode x1=d[i]; abc.insert(x1); } System.out.println("初始堆"); abc.outMinHeap(); for(int i=m;i<=n1;i++) { jobNode x=abc.removemin(); System.out.println("移出x="+x.time); x.time=x.time+d[i].time; abc.insert(x); } System.out.println("各台机器最终运行时间"); abc.outMinHeap(); } } } 3.时间复杂度分析 当n≤m 时，所有作业可以一次安排给各机器，算法greedy需要o(1) 时间。当n>m 时，排序耗时O(nlogn)。初始化堆需要O(m) 时间。关于堆的removeMin 和put运算共耗时O(nlogm),因此算法greedy 所需的计算时间为O(nlogn+nlogm)=O(nlogn)。 心得体会： 这次实验使我熟练掌握了贪心算法，同时认识到自己的不足，并且回顾了之前的学习，为毕业设计打下了基础，在处理问题的过程中，我查找了很多资料，养成了自主思考问题的习惯，并且丰富了课余时间。 参考文献： 《计算机操作系统》（第四版）西安电子科技大学出版社 《算法设计与分析》（第二版）清华大学出版社 《java程序设计教程》西安电子科技大学出版社 《数据结构及算法》清华大学出版社 数据结构课程设计报告 贪心算法：任务调度问题的设计 专业 学生姓名 班级 学 号 指导教师 完成日期 贪心算法：任务调度问题的设计 目录 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、MST性质 2、子问题的重叠性质 递归算法求解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次，这种性质称为子问题的重叠性质。 二、简答题 1、简述动态规划算法求解的基本要素。 答：动态规划算法求解的基本要素包括： 1)最优子结构是问题能用动态规划算法求解的前提； 2)动态规划算法，对每一个子问题只解一次，而后将其解保存在一个表格中，当再次需要解此子问题时，只是简单地用常数时间查看一下结果，即重叠子问题。 2、备忘录方法和动态规划算法相比有何异同简述之。 答：备忘录方法是动态规划算法的变形。与动态规划算法一样，备忘录方法用表格保存已解决的子问题的答案，在下次需要解此问题时，只要简单地查看该子问题的解答，而不必重新计算。备忘录方法与动态规划算法不同的是，备忘录方法的递归方式是自顶向下的，而动态规划算法则是自底向上递归的。因此，备忘录方法的控制结构与直接递归方法的控制结构相同，区别在于备忘录方法为每个解过的子问题建立了备忘录以备需要时查看，避免了相同的子问题的重复求解，而直接递归方法没有此功能。 3、贪心算法求解的问题主要具有哪些性质简述之。 答：贪心算法求解的问题一般具有二个重要的性质： 一是贪心选择性质，这是贪心算法可行的第一个基本要素； 另一个是最优子结构性质，问题的最优子结构性质是该问题可用贪心算法求解的关键特征。 三、算法编写及算法应用分析题 1、设计求解如下最大子段和问题的动态规划算法。只需给出其递推计算公式即可。 最大子段和问题：给定由n 个整数（可能为负整数）组成的序列a1a2 … an，求该序列形如Σi≤k≤j ak的子段和的最大值。当所有整数均为负整数时定义其最大子段和为0。依次定义，所求的最优值为max{0, max1≤i≤j≤n Σi≤k≤j ak }。 智能算法在柔性作业车间调度中的应用摘要：为提高企业生产效率，合理的流水车间生产调度显得尤为重要。本文介绍了三种智能算法（蚁群算法、遗传算法、改进粒子群算法）在车间生产调度中的应用，主要介绍了算法的基本思想、模型结构、算法实现以及运用前景。对智能算法在生产调度中的应用做出总结。 关键字：智能算法；蚁群算法；遗传算法；改进粒子群算法；生产调度 0.前言 柔性作业车间调度问题(Flexible job-shop sche- duling problem, FJSP)是传统作业车间调度 问题的扩展，是实际生产中迫切需要解决的一类问 题。在传统的作业车间调度问题中，工件的每道工序只能在一台确定的机床上加工。而在柔性作业车间调度问题中，每道工序可以在多台机床上加工，并且在不同的机床上加工所需时间不同。柔性作业车间调度问题减少了机器约束，扩大了可行解的搜索范围，增加了问题的难度。 作业车间的主要特点是：n个工件需要在m台机器上进行加工，每个工件都有其独特的加工步骤，但无明显的顺序约束，并且加工时间是已知的，调度的目标是在不允许两个工件同时在同一台机器上加工的前提下，如何安排工件在每台机器上的加工顺序使这些工件能够尽快加工完毕[1]。 1.蚁群算法在作业车间的应用[2] 以3个工件2台机器的问题作为例子，如图1。 图1 三个工件两台机器的JSP问题 为确定先对哪个工件进行加工，需要设置一个初始节点O0，所有的蚂蚁最初都放置在O0。图1中除与O0相连的有向弧表示同一个工件的加工顺序，工件必须按照该顺序进行加工。其它则为无向弧。每个弧与表示节点间信息素的量和启发式距离的一对 值{αij, d ij}有关。d ij 通常为对节点 j 的第 i 步操作的加工时间，τij使用蚁周方式进行更新：其中，ρ是个系数，1?ρ表示在时间t和t+1之间信息素的蒸发，Q为常数，Tk为完成所有加工步骤后最短的总加工时间。初始时刻τij(0)= c（c为常数）。 这个规则包含了两个方面：(1)图1中所有边缘上的信息素都要蒸发；(2)完成所有的加工后要将该解的效果加到各边缘上。蒸发可以防止搜索局限在局部最小的邻域中，另一方面又能根据已有解的效果好坏来更新信息素，进行增强学习。 另一个关键的问题就是如何保证蚂蚁按照工件的工艺路线产生一组可行解。这里用到3个集合：对每个蚂蚁 k，首先要有集合G k，表示没有访问过的节点集合；S k 表示根据技术路线下一步允许访问的节点集合；还需要一个禁忌表，存放已经访问过的节点。在我们的例子中， G k ={1，2 ，3，4，5 ，6}，S k ={1，2 ，3}。转移概率是通过下式计算的： T ij 为工件i在机器j上的加工时间。每选择一个节点，该节点就被追加到禁忌表中并从G k和 S k中删除；如果被选的节点不是工件的最后一步，那该工件中紧邻的下一个节点会被加到Sk中。该过程一直重复到G k = φ。最后禁忌表中得到的节点的排列顺序就是蚂蚁 k 找到的解。 参数α和β决定了算法的收敛速度并对解的性能好坏有重要影响，同时蒸发常数也需要进行适当的调整以使搜索能在好的搜索空间中进行，并防止陷入局部最优的邻域中。 操作系统实验报告（二） 实验题目：进程调度算法 实验环境：C++ 实验目的：编程模拟实现几种常见的进程调度算法，通过对几组进程分别使用不同的调度算法，计算进程的平均周转时间和平均带权周转时间，比较 各种算法的性能优劣。 实验内容：编程实现如下算法： 1.先来先服务算法； 2.短进程优先算法； 3.时间片轮转调度算法。 设计分析： 程序流程图： 1.先来先服务算法 开始 初始化PCB，输入进程信息 各进程按先来先到的顺序进入就绪队列 结束 就绪队列？ 运行 运行进程所需CPU时间 取消该进程 2.短进程优先算法 3.时间片轮转调度算法 实验代码： 1.先来先服务算法 #include int atime; //进程到达时间 int runtime; //进程运行时间 }fcs; void main() { int amount,i,j,diao,huan; fcs f[n]; cout<<"请输入进程个数:"< 贪心算法会场安排问题算法设计分析Description 假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。设计一个有效的算法进行安排。(这个问题实际上是著名的图着色问题。若将每一个活动作为图的一个顶点，不相容活动间用边相连。使相邻顶点着有不同颜色的最小着色数，相应于要找的最小会场数。) 编程任务： 对于给定的k个待安排的活动，编程计算使用最少会场的时间表。 Input 输入数据是由多组测试数据组成。每组测试数据输入的第一行有1 个正整数k，表示有k个待安排的活动。接下来的k行中，每行有2个正整数，分别表示k 个待安排的活动开始时间和结束时间。时间以0 点开始的分钟计。 Output 对应每组输入，输出的每行是计算出的最少会场数。 Sample Input 5 1 23 12 28 25 35 27 80 3 6 50 Sample Output 3 程序： #include 流水线车间生产调度的遗传算法MATLAB源代码 n个任务在流水线上进行m个阶段的加工，每一阶段至少有一台机器且至少有一个阶段存在多台机器，并且同一阶段上各机器的处理性能相同，在每一阶段各任务均要完成一道工序，各任务的每道工序可以在相应阶段上的任意一台机器上加工，已知任务各道工序的处理时间，要求确定所有任务的排序以及每一阶段上机器的分配情况，使得调度指标(一般求Makespan)最小。 function [Zp,Y1p,Y2p,Y3p,Xp,LC1,LC2]=JSPGA(M,N,Pm,T,P) %-------------------------------------------------------------------------- % JSPGA.m % 流水线型车间作业调度遗传算法 % GreenSim团队——专业级算法设计&代写程序 % 欢迎访问GreenSim团队主页→https://www.wendangku.net/doc/ea472243.html,/greensim %-------------------------------------------------------------------------- % 输入参数列表 % M 遗传进化迭代次数 % N 种群规模(取偶数) % Pm 变异概率 % T m×n的矩阵，存储m个工件n个工序的加工时间 % P 1×n的向量，n个工序中，每一个工序所具有的机床数目 % 输出参数列表 % Zp 最优的Makespan值 % Y1p 最优方案中，各工件各工序的开始时刻，可根据它绘出甘特图 % Y2p 最优方案中，各工件各工序的结束时刻，可根据它绘出甘特图 % Y3p 最优方案中，各工件各工序使用的机器编号 % Xp 最优决策变量的值，决策变量是一个实数编码的m×n矩阵 % LC1 收敛曲线1，各代最优个体适应值的记录 % LC2 收敛曲线2，各代群体平均适应值的记录 % 最后，程序还将绘出三副图片：两条收敛曲线图和甘特图（各工件的调度时序图） %第一步：变量初始化 [m,n]=size(T);%m是总工件数，n是总工序数 Xp=zeros(m,n);%最优决策变量 LC1=zeros(1,M);%收敛曲线1 LC2=zeros(1,N);%收敛曲线2 %第二步：随机产生初始种群 farm=cell(1,N);%采用细胞结构存储种群 for k=1:N X=zeros(m,n); for j=1:n for i=1:m X(i,j)=1+(P(j)-eps)*rand; 华东师范大学计算机科学技术系上机实践报告 课程名称：算法设计与分析年级：05上机实践成绩： 指导教师：柳银萍姓名：张翡翡 上机实践名称：贪心算法学号：10052130119上机实践日期：2007-4-10 上机实践编号：NO.2组号：上机实践时间：10:00-11:30 一、目的 了解熟悉掌握贪心算法实质并学会灵活运用，从而解决生活中一些实际问题。 二、内容与设计思想 1.超市的自动柜员机(POS)要找给顾客各种数值的现金，表面上看，这是一个很简单的任务，但交给机器办就不简单了。你作为一个计算机专家，要求写一个程序来对付这个“简单”的问题。 你的自动柜员机有以下的币种：100元，50元，20元，10元，5元，2元，1元。你可以假设每种钱币的数量是无限的。现在有一笔交易，需要找个客户m元，请你设计一个算法，使得找给顾客的钱币张数最少。 要求： 输入：第一行仅有一个整数n(0 先来先服务FCFS和短作业优先SJF进程调度算法 1、实验目的 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。 2、需求分析 (1) 输入的形式和输入值的范围 输入值：进程个数Num 范围：0 说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。 4、详细设计 5、调试分析 (1)调试过程中遇到的问题以及解决方法，设计与实现的回顾讨论和分析 ○1开始的时候没有判断进程是否到达，导致短进程优先算法运行结果错误，后来加上了判断语句后就解决了改问题。 ○2 基本完成的设计所要实现的功能，总的来说，FCFS编写容易，SJF 需要先找到已经到达的进程，再从已经到达的进程里找到进程服务时间最短的进程，再进行计算。 (2)算法的改进设想 改进：即使用户输入的进程到达时间没有先后顺序也能准确的计算出结果。（就是再加个循环，判断各个进程的到达时间先后，组成一个有序的序列） (3)经验和体会 通过本次实验，深入理解了先来先服务和短进程优先进程调度算法的思想，培养了自己的动手能力，通过实践加深了记忆。 6、用户使用说明 （1）输入进程个数Num 【贪心算法】思想 & 基本要素 & 贪心算法与局部最优 & 贪心算法与动态规划的区别 & 运用贪心算法求解问题 首先我们先代入问题来认识一下贪心算法涉及的问题 找钱问题 给顾客找钱，希望找零的钞票尽可能少，零钱种类和数量限定 找钱问题满足最优子结构 最快找零（贪心）：为得到最小的找零次数，每次最大程度低减少零额活动安排问题 设个活动都需要使用某个教室，已知它们的起始时间和结束时间，求合理的安排使得举行的活动数量最多 贪心：使得每次安排后，教室的空闲时间最多 解决过程如下： 贪心算法求得的相容活动集是最大的 第一步：证明最优解中包含结束时间最早的活动 设相容集 A 是一个最优解，其结束最早的活动为 a，则 ( A - { a }) U { 1 } 也是一个最优解 第二步：证明去掉结束时间最早的活动后，得到的子问题仍是最优的：反证法 理解贪心算法 贪心算法总是做出当前最好的选择 贪心选择的依据是当前的状态，而不是问题的目标 贪心选择是不计后果的 贪心算法通常以自顶向下的方法简化子问题 贪心算法求解的问题具备以下性质 贪心选择性质：问题的最优解可以通过贪心选择实现 最优子结构性质：问题的最优解包含子问题的最优解 贪心选择性质的证明 证明问题的最优解可以由贪心选择开始 即第一步可贪心 证明贪心选择后得到的子问题满足最优子结构 即步步可贪心 背包问题 问题描述：给定 n 个物品和一个背包。物品 i 的重量为 Wi ，价值为 Vi ，背包的容量为 c ，问如何选择物品或物品的一部分，使得背包中物品的价值最大？ 当 n = 3 ，c = 50 0-1背包问题：装入物品2、3，最大价值220 背包问题：装入物品1、2和2-3的物品3，最大价值240（贪心算法）贪心算法无法求解0-1背包问题，按贪心算法，0-1背包问题将装入物品1和2 贪心与局部最优 思考：为什么0-1背包可以用动态规划？而不能用贪心算法 贪心易陷入局部最优 //多机调度问题 /* 贪心法求解多级调度问题的贪心策略师最长处理时间的作业优先，即把处理时间最长的作业分配给最先空闲的机器，这样就可以保证处理时间长的 作业优先处理，从而在整体上获得尽可能短的时间。按照最长处理时间作业优先的贪心测落，当m>n,时，只要将机器ide [0,ti)时间去见分配给作业j即可， 当m 作业调度实验报告 Document number：NOCG-YUNOO-BUYTT-UU986-1986UT 实验二作业调度 一.实验题目 1、编写并调试一个单道处理系统的作业等待模拟程序。 作业调度算法：分别采用先来先服务（FCFS），最短作业优先（SJF）、响应比高者优先（HRN）的调度算法。 （1）先来先服务算法：按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。 （2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准，总是优先选取执行时间最短的作业。 （3）响应比高者优先算法：是在每次调度前都要计算所有被选作业（在后备队列中）的响应比，然后选择响应比最高的作业执行。 2、编写并调度一个多道程序系统的作业调度模拟程序。 作业调度算法：采用基于先来先服务的调度算法。可以参考课本中的方法进行设计。 对于多道程序系统，要假定系统中具有的各种资源及数量、调度作业时必须考虑到每个作业的资源要求。 二.实验目的： 本实验要求用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三 .实验过程 <一>单道处理系统作业调度 1)单道处理程序作业调度实验的源程序: 执行程序: 2)实验分析： 1、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的 CPU 时限等因素。 2、每个作业由一个作业控制块JCB 表示，JCB 可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W 。 3、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。 3)流程图: 二.最短作业优先算法 三.高响应比算法 图一.先来先服务流程图 4)源程序: #include <> #include <> #include <> #define getpch(type) (type*)malloc(sizeof(type)) #define NULL 0 int n; float T1=0,T2=0; int times=0; struct jcb .\n",p->name); free(p); .wait...",time); if(times>1000) 代替 代替 陕西师大计科院2009级《算法设计与分析》课程论文集 算法设计（贪心算法解决活动安排） 设计者：朱亚君 贪心算法的计算过程如下图所示。图中每行相应于算法的一次迭代。阴影长条表示的活动是已选入集合A的活动，而空白长条表示的活动是当前正在检查相容性的活动。 图1贪心算法的计算过程图 若被检查的活动i的开始时间Si小于最近选择的活动j的结束时间fi，则不选择活动i，否则选择活动i加入集合A中。 贪心算法并不总能求得问题的整体最优解。但对于活动安排问题，贪心算法却总能求得的整体最优解，即它最终所确定的相容活动集合A的规模最大。这个结论可以用数学归纳法证明。 运用贪心算法解决活动安排问题 附录： 贪心算法的实现具体程序如下： // 贪心算法实现代码 n为活动个数 s为活动开始起始时间队列 f 为活动结束队列 A为已选入集合 import java.util.Scanner; public class a { /** * @param args */ static void GreedySelector(int s[],int f[],boolean A[]) { //第一个活动为结束时间最早进入选入队列 int n=s.length; A[1]=true; int j=2; for(int i=2;i 活动安排 public static int greedySelector(int [] s, int [] f, boolean a[]) { //s[]开始时间f[]结束时间 int n=s.length-1; a[1]=true; int j=1; int count=1; for (int i=2;i<=n;i++) { if (s[i]>=f[j]) { a[i]=true; j=i; count++; } else a[i]=false; } return count; } 背包问题 void Knapsack(int n,float M,float v[],float w[],float x[]) { Sort(n,v,w); //以每种物品单位重量的价值Vi/Wi从大到小排序 int i; for (i=1;i<=n;i++) x[i]=0; float c=M; for (i=1;i<=n;i++) { if (w[i]>c) break; x[i]=1; c-=w[i]; } if (i<=n) x[i]=c/w[i]; //允许放入一个物品的一部分 } 最优装载 void Loading(int x[], T ype w[], T ype c, int n) { int *t = new int [n+1]; //t[i]要存的是w[j]中重量从小到大的数组下标Sort(w, t, n); //按货箱重量排序 for (int i = 1; i <= n; i++) x[i] = 0; //O(n) for (int i = 1; i <= n && w[t[i]] <= c; i++) {x[t[i]] = 1; c -= w[t[i]];} //调整剩余空间 } 单源最短路径Dijiksra template 作业调度 一、实验目的 1、对作业调度的相关内容作进一步的理解。 2、明白作业调度的主要任务。 3、通过编程掌握作业调度的主要算法。 二、实验内容及要求 1、对于给定的一组作业, 给出其到达时间和运行时间，例如下表所示： 2、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。 3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。 测试数据 workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} 运行结果 先来先服务算法 调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间: 带权周转时间: 短作业优先算法 调度顺序:['A', 'D', 'F', 'C', 'E', 'B'] 周转时间: 带权周转时间:1. 响应比高者优先算法 调度顺序:['A', 'D', 'F', 'E', 'C', 'B'] 周转时间: 带权周转时间: 五、代码 #encoding=gbk workA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8} list1=[workB,workA,workC,workD,workE,workF] list2=[workB,workA,workC,workD,workE,workF] list3=[workB,workA,workC,workD,workE,workF] #先来先服务算法 def fcfs(list): resultlist = sorted(list, key=lambda s: s['到达时间']) return resultlist #短作业优先算法 def sjf(list): time=0 resultlist=[] for work1 in list: time+=work1['服务时间'] listdd=[] ctime=0 for i in range(time): for work2 in list: if work2['到达时间']<=ctime: (work2) if len(listdd)!=0: li = sorted(listdd, key=lambda s: s['服务时间']) (li[0]) (li[0]) ctime+=li[0]['服务时间'] listdd=[] 《操作系统》实验报告 题目：作业调度算法 班级：网络工程 姓名：朱锦涛 学号：E31314037 一、实验目的 用代码实现页面调度算法，即先来先服务（FCFS）调度算法、短作业优先算法、高响应比优先调度算法。通过代码的具体实现，加深对算法的核心的理解。 二、实验原理 1.先来先服务（FCFS）调度算法 FCFS是最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，系统将按照作业到达的先后次序来进行调度，或者说它是优先考虑在系统中等待时间最长的作业，而不管该作业所需执行的时间的长短，从后备作业队列中选择几个最先进入该队列的作业，将它们调入内存，为它们分配资源和创建进程。然后把它放入就绪队列。 2.短作业优先算法 SJF算法是以作业的长短来计算优先级，作业越短，其优先级越高。作业的长短是以作业所要求的运行时间来衡量的。SJF算法可以分别用于作业和进程调度。在把短作业优先调度算法用于作业调度时，它将从外存的作业后备队列中选择若干个估计运行时间最短的作业，优先将它们调入内存。 3、高响应比优先调度算法 高响应比优先调度算法则是既考虑了作业的等待时间，又考虑了作业的运行时间的算法，因此既照顾了短作业，又不致使长作业等待的时间过长，从而改善了处理机调度的性能。 如果我们引入一个动态优先级，即优先级是可以改变的令它随等待的时间的延长而增加，这将使长作业的优先级在等待期间不断地增加，等到足够的时间后，必然有机会获得处理机。该优先级的变化规律可以描述为： 优先权 = （等待时间 + 要求服务时间）/要求服务时间 三、实验内容 源程序： #include 贪心算法求解多机调度问题 设有n项独立的作业{1,2,…, n},由m 台相同的机器加工处理。作业i 所需要的处理时间为台相同的机器加工处理。设有n 项独立的作业由ti。约定：任何一项作业可在任何一台机器上处理，但未完工前不准中断处理；任何作业不能拆分成更小的子作业。多机调度问题要求给出一种调度方案，能拆分成更小的子作业。多机调度问题要求给出一种调度方案，使所给的n 个作业在尽可台机器处理完。利用贪心策略，设计贪心算法解决多机调度问题，能短的时间内由m 台机器处理完。利用贪心策略，设计贪心算法解决多机调度问题，并计算其时间复杂度。 多机调度问题的一个实例： 多机调度问题的一个实例：项独立的作业{1,2,3,4,5,6,7}，要由三台机器M1, M2 ,M3 处理。各个作业所需处理。各个作业所需例如设有7 项独立的作业，要的处理时间分别为{2,14,4,16,6,5,3}。利用你设计的贪心算法，要的处理时间分别为。利用你设计的贪心算法，安排作业的处理顺序使得机器处理作业的时间最短。器处理作业的时间最短。 #include Greedy(t,n,m); return 0; } void Greedy(int t[],int n,int m) { int flagn,flagm; int M[]={0,0,0,0,0,0,0,0}; for(int i=0;i 中原工学院计算机学院 实验报告 实验项目名称实验二、最少活动会场安排问题课程名称算法设计与分析 学生姓名梁斐燕 学生学号201400824204 所在班级网络14卓越 学科专业网络工程 任课教师吴志刚 完成日期2016年月日 实验二最少活动会场安排问题 一、实验目的 1．掌握贪心算法的基本概念和两个基本要素 2．熟练掌握贪心算法解决问题的基本步骤。 3．学会利用贪心算法解决实际问题。 二、实验内容 ?问题描述： ?题目一：假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。设计一个有效的贪心算法来进行安排，试编程实现。 ?题目二：一辆汽车加满油后,可行使n千米。旅途中有若干个加油站。 若要使沿途加油次数最少,设计一个有效算法，指出应在哪些加油站停靠加油。 ?数据输入：个人设定，由键盘输入。 ?要求： –上述题目任选一做。上机前，完成程序代码的编写 –独立完成实验及实验报告 三、实验步骤 ㈠、数据结构与核心算法的设计描述 提示：题目一：参考教材活动安排问题；有关队列操作参考数据结构。void GreedySelector(int n, int *s, int *f, int *A) { //用集合A来存储所选择的活动 A[1] = TURE; //默认从第一次活动开始执行 int j = 1; //j记录最近一次加入到A中的活动 for (int i = 2; i <= n; i++) { //f[j]为当前集合A中所有活动的最大结束时间//活动i的开始时间不早于最近加入到集合A中的j的时间f[j] if (s[i] >= f[j]) { A[i] = TURE; //当A[i]=TURE时，活动i在集合A中 j = i; } else A[i] = FALSE; } } ㈡、函数调用及主函数设计 （可用函数的调用关系图说明） 主函数 快排选择活动 FCFS和SJF进程调度算法实验报告 【实验题目】：编写程序，实现FCFS和SJF算法，模拟作 业调度过程，加深对作业调度的理解。 【实验内容】 实现FCFS和SJF调度算法。 –数据结构设计（JCB，后备作业队列） –算法实现与模拟（排序、调度） –输出调度结果，展示调度过程并解释 【实验要求】 1. 设计作业控制块(JCB)的数据结构 –应包含实验必须的数据项，如作业ID、需要的服务时间、进入系 统时间、完成时间，以及实验者认为有必要的其他数据项。 2. 实现排序算法（将作业排队） –策略1：按“进入系统时间”对作业队列排序(FCFS) –策略2：按“需要的服务时间”对作业队列排序（SJF） 3. 实现调度过程模拟 （1）每个作业用一个JCB表示，如果模拟FCFS，按策略1将作业排队，如果模拟SJF，按策略2将作业排队（2）选择队首的作业，将其从后备队列移出 （3）（作业运行过程，在本实验中，无需实现，可认为后备队列的 作业一但被调度程序选出，就顺利运行完毕，可以进入第4步） （4）计算选中作业的周转时间 （5）进行下一次调度（去往第2步） 4.实现结果输出 –输出作业状态表，展示调度过程 ?初始作业状态（未调度时） ?每次调度后的作业状态 设计作业控制块(JCB)的数据结构 每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。具体结构如下：typedef struct jcb{ char name[10]; /* 作业名*/ char state; /* 作业状态*/ int ts; /* 提交时间*/ float super; /* 优先权*/ int tb; /* 开始运行时间*/ int tc; /* 完成时间*/ float ti; /* 周转时间*/ float wi; /* 带权周转时间*/ int ntime; /* 作业所需运行时间*/ char resource[10]; /* 所需资源*/ struct jcb *next; /* 结构体指针*/ } JCB; JCB *p,*tail=NULL,*head=NULL; 作业的状态可以是等待W(Wait)、运行R(Run)和完成F(Finish)三种状态之一。每个作业的最初状态总是等待W。，组成一个后备队列等待，总是首先调度等待队列中队首的作业。课程设计报告-贪心算法：任务调度问题
算法分析与设计(线下作业二)
(完整版)智能算法在柔性车间调度中的应用
进程调度算法实验报告
贪心算法 会场安排问题 算法设计分析
02流水线车间生产调度的遗传算法MATLAB源代码
实验二(贪心算法)
先来先服务FCFS和短作业优先SJF进程调度算法_实验报告材料
贪 心 算 法
贪心法 多机调度问题
作业调度实验报告
算法设计(eclipse编写贪心算法设计活动安排)
贪心算法经典问题：活动安排,背包问题,最优装载,单源最短路径 Dijiksra,找零钱问题,多机调度
操作系统实验报告-作业调度
作业调度算法(先来先服务算法,短作业算法)
贪心算法求解多机调度问题
实验二 贪心算法-最少活动会场安排问题
FCFS和SJF进程调度算法实验报告