算法分析与设计-独立任务最优调度问题实验报告
动态规划法-1.独立任务最优调度问题C++实现
动态规划法-1.独⽴任务最优调度问题C++实现问题描述：⽤2台处理机A和B处理n个作业。
设第i个作业交给机器A处理时需要时间，若由机器B来处理，则需要时间。
由于各作业的特点和机器的性能关系，很可能对于某些i，有，⽽对于某些j,j≠i，有。
既不能将⼀个作业分开由2台机器处理，也没有⼀台机器能同时处理2个作业。
设计⼀个动态规划算法，使得这2台机器处理完这n个作业的时间最短(从任何⼀台机器开⼯到最后⼀台机器停⼯的总时间)。
研究⼀个实例：(a1,a2,a3,a4,a5,a6)＝(2,5,7,10,5,2)；(b1,b2,b3,b4,b5,b6)＝(3,8,4,11,3,4)。
算法设计：对于给定的2台处理机A和B处理n个作业，找出⼀个最优调度⽅案，使2台机器处理完这n个作业的时间最短。
数据输⼊：由⽂件input.txt提供输⼊数据。
⽂件的第1⾏是1个正整数n, 表⽰要处理n个作业。
接下来的2⾏中，每⾏有n个正整数，分别表⽰处理机A和B 处理第i个作业需要的处理时间。
结果输出:将计算出的最短处理时间输出到⽂件output.txt中。
输⼊⽂件⽰例输出⽂件⽰例input.txt output.txt1562 5 7 10 5 23 84 11 3 4问题分析：对于这个问题，我们可以考虑，当完成第k个任务时，有两种可能：⼀是A处理机完成了第k个任务，那么B处理机完成k个任务的最短时间就与B处理机完成k-1个任务所需的最短时间是相同的⼆是B处理机完成了第k个任务，那么B处理机完成k个任务的最短时间就等于B处理机完成k-1个任务的最短时间加上B处理机完成第k个任务所需要的时间设F[k][x]表⽰完成第k个任务时A耗费的时间为x的情况下B所花费的最短时间，其中0<=k <= n， 0<=x<= Σai，那么，状态转移⽅程为F[k] [x]=minF[k−1][x−ak],F[k−1][x]+bk处理好特殊情况（如x⼩于0时）开始填表即可。
任务调度实验报告
一、实验目的1. 理解任务调度的基本概念和原理。
2. 掌握任务调度的常用算法和策略。
3. 通过实验，验证任务调度算法的性能和效率。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 任务调度算法：基于优先级、基于时间、基于轮转等。
2. 实验任务：模拟多任务并行执行，测试不同调度算法的性能。
四、实验步骤1. 定义任务类```pythonclass Task:def __init__(self, task_id, arrival_time, execution_time): self.task_id = task_idself.arrival_time = arrival_timeself.execution_time = execution_timeself.finish_time = 0self.wait_time = 0```2. 定义任务调度类```pythonclass TaskScheduler:def __init__(self):self.tasks = []def add_task(self, task):self.tasks.append(task)def schedule_tasks(self, algorithm):passdef get_task_info(self):for task in self.tasks:print(f"Task ID: {task.task_id}, Arrival Time:{task.arrival_time}, Execution Time: {task.execution_time}, Finish Time: {task.finish_time}, Wait Time: {task.wait_time}")```3. 定义基于优先级的调度算法```pythonclass PriorityScheduler(TaskScheduler):def schedule_tasks(self):self.tasks.sort(key=lambda x: x.arrival_time)self.tasks.sort(key=lambda x: x.execution_time, reverse=True)for task in self.tasks:task.finish_time = task.arrival_time + task.execution_timetask.wait_time = task.finish_time - task.arrival_time```4. 定义基于时间的调度算法```pythonclass TimeScheduler(TaskScheduler):def schedule_tasks(self):current_time = 0for task in self.tasks:if task.arrival_time <= current_time:task.finish_time = current_time + task.execution_time task.wait_time = task.finish_time - task.arrival_time current_time = task.finish_time```5. 定义基于轮转的调度算法```pythonclass RoundRobinScheduler(TaskScheduler):def __init__(self, quantum):super().__init__()self.quantum = quantumdef schedule_tasks(self):current_time = 0index = 0while index < len(self.tasks):task = self.tasks[index]if task.arrival_time <= current_time:if task.execution_time <= self.quantum:task.finish_time = current_time +task.execution_timetask.wait_time = task.finish_time -task.arrival_timecurrent_time = task.finish_timeindex += 1else:task.finish_time = current_time + self.quantumtask.wait_time = task.finish_time -task.arrival_timecurrent_time = task.finish_timetask.execution_time -= self.quantumelse:current_time = max(current_time, task.arrival_time) index += 1```6. 添加任务并执行调度```pythonscheduler = PriorityScheduler()scheduler.add_task(Task(1, 0, 5))scheduler.add_task(Task(2, 1, 3))scheduler.add_task(Task(3, 4, 2))scheduler.schedule_tasks()scheduler.get_task_info()```五、实验结果与分析1. 基于优先级的调度算法：任务执行顺序为3, 1, 2，平均等待时间为2.6667。
算法分析与设计-实验四 作业调度问题-实验报告
南阳理工学院算法分析与设计实验报告册开课学院：计算机与软件学院实验项目：实验4：贪心法（作业调度问题）实验时间：第10周周3（3,4）节实验地点： 15#515指导教师：学生姓名：学生学号：专业班级：2020-2021学年第1学期一、实验目的1.了解贪心算法思想及基本原理2.掌握使用贪心算法求解问题的一般特征3.能够针对实际问题，能够正确选择贪心策略4.能够针对选择的贪心策略，证明算法的正确性5.能够根据贪心策略，正确编码6.能够正确分析算法的时间复杂度和空间复杂度二、实验平台1.JDK1.82.IDEA三、实验内容设有n个独立的作业{1, 2, …,n}，由m台相同的机器{M1, M2, …,Mm}进行加工处理，作业i所需的处理时间为ti （1≤i≤n），每个作业均可在任何一台机器上加工处理，但不可间断、拆分。
多机调度问题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
提示：贪心法求解多机调度问题的贪心策略是最长处理时间作业优先，即把处理时间最长的作业分配给最先空闲的机器，这样可以保证处理时间长的作业优先处理，从而在整体上获得尽可能短的处理时间。
按照最长处理时间作业优先的贪心策略，当m≥n时，只要将机器i的[0, ti)时间区间分配给作业i即可；当m＜n时，首先将n 个作业依其所需的处理时间从大到小排序，然后依此顺序将作业分配给空闲的处理机。
四、算法设计1.问题分析设有n个独立的作业{1, 2, …, n}, 由m台相同的机器进行加工处理. 作业i所需时间为t i. 约定:任何作业可以在任何一台机器上加工处理, 但未完工前不允许中断处理,任何作业不能拆分成更小的子作业。
要求给出一种作业调度方案，使所给的n 个作业在尽可能短的时间内由m台机器加工处理完成。
多机调度问题是一个NP完全问题，到目前为止还没有完全有效的解法。
对于这类问题，用贪心选择策略有时可以设计出一个比较好的近似算法。
算法设计与分析的实验报告
实验一递归与分治策略一、实验目的1．加深学生对分治法算法设计方法的基本思想、基本步骤、基本方法的理解与掌握；2．提高学生利用课堂所学知识解决实际问题的能力；3．提高学生综合应用所学知识解决实际问题的能力。
二、实验内容1、①设a[0:n-1]是已排好序的数组。
请写二分搜索算法，使得当搜索元素x不在数组中时，返回小于x的最大元素位置i和大于x的最小元素位置j。
当搜索元素在数组中时，i和j相同，均为x在数组中的位置。
②写出三分搜索法的程序。
三、实验要求（1）用分治法求解上面两个问题；（2）再选择自己熟悉的其它方法求解本问题；（3）上机实现所设计的所有算法；四、实验过程设计（算法设计过程）1、已知a[0:n-1]是一个已排好序的数组，可以采用折半查找（二分查找）算法。
如果搜索元素在数组中，则直接返回下表即可；否则比较搜索元素x与通过二分查找所得最终元素的大小，注意边界条件，从而计算出小于x的最大元素的位置i和大于x的最小元素位置j。
2、将n个元素分成大致相同的三部分，取在数组a的左三分之一部分中继续搜索x。
如果x>a[2(n-1)/3]，则只需在数组a的右三分之一部分中继续搜索x。
上述两种情况不成立时，则在数组中间的三分之一部分中继续搜索x。
五、实验结果分析二分搜索法：三分搜索法：时间复杂性：二分搜索每次把搜索区域砍掉一半，很明显时间复杂度为O(log n)。
（n代表集合中元素的个数）三分搜索法：O（3log3n）空间复杂度：O（1）。
六、实验体会本次试验解决了二分查找和三分查找的问题，加深了对分治法的理解，收获很大，同时我也理解到学习算法是一个渐进的过程，算法可能一开始不是很好理解，但是只要多看几遍，只看是不够的还要动手分析一下，这样才能学好算法。
七、附录：（源代码）二分搜索法：#include<iostream.h>#include<stdio.h>int binarySearch(int a[],int x,int n){int left=0;int right=n-1;int i,j;while(left<=right){int middle=(left+right)/2;if(x==a[middle]){i=j=middle;return 1;}if(x>a[middle])left=middle+1;else right=middle-1;}i=right;j=left;return 0;}int main(){ int a[10]={0,1,2,3,4,5,6,7,8,9};int n=10;int x=9;if(binarySearch(a,x,n))cout<<"找到"<<endl;elsecout<<"找不到"<<endl;return 0;}实验二动态规划——求解最优问题一、实验目的1．加深学生对动态规划算法设计方法的基本思想、基本步骤、基本方法的理解与掌握；2．提高学生利用课堂所学知识解决实际问题的能力；3．提高学生综合应用所学知识解决实际问题的能力。
操作系统实验报告——调度算法
操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法，通过编写代码模拟不同的调度算法，了解它们的特点和应用场景。
2. 实验环境本次实验使用的操作系统环境为Linux，并采用C语言进行编码。
3. 实验内容3.1 调度算法1：先来先服务（FCFS）FCFS调度算法是一种简单且常见的调度算法。
该算法按照进程到达的先后顺序进行调度。
在本实验中，我们使用C语言编写代码模拟FCFS算法的调度过程，并记录每个进程的等待时间、周转时间和响应时间。
3.2 调度算法2：最短作业优先（SJF）SJF调度算法是一种非抢占式的调度算法，根据进程的执行时间来选择下一个要执行的进程。
在本实验中，我们使用C语言编写代码模拟SJF算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
3.3 调度算法3：轮转调度（Round Robin）Round Robin调度算法是一种经典的时间片轮转算法，每个进程在给定的时间片内依次执行一定数量的时间。
如果进程的执行时间超过时间片，进程将被暂时挂起，等待下一次轮转。
在本实验中，我们使用C语言编写代码模拟Round Robin算法的调度过程，并计算每个进程的等待时间、周转时间和响应时间。
4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析，可以得出以下结论：- FCFS算法适用于任务到达的先后顺序不重要的场景，但对于执行时间较长的进程可能会导致下一个进程需要等待较久。
- SJF算法适用于任务的执行时间差异较大的场景，能够提高整体执行效率。
- Round Robin算法适用于时间片相对较小的情况，能够公平地为每个进程提供执行时间。
5. 实验总结本次实验通过模拟不同调度算法的实际执行过程，深入了解了各种调度算法的原理、特点和适用场景。
通过对实验结果的分析，我们可以更好地选择合适的调度算法来满足实际应用的需求。
在后续的学习中，我们将进一步探索更多操作系统相关的实验和算法。
调度的调度算法实验报告
调度的调度算法实验报告调度的调度算法实验报告引言：调度是计算机科学中一个重要的概念，它涉及到任务分配、资源管理和优化等方面。
调度算法则是实现调度的关键，它决定了任务的执行顺序和资源的分配方式。
在本次实验中，我们将探讨几种常见的调度算法，并通过实验对其性能进行评估和比较。
一、先来先服务算法（FCFS）先来先服务算法是最简单的调度算法之一，它按照任务到达的先后顺序进行处理。
实验中，我们模拟了一个任务队列，每个任务有不同的执行时间。
通过实验结果可以看出，FCFS算法的优点是简单易懂，但当任务的执行时间差异较大时，会导致平均等待时间较长。
二、最短作业优先算法（SJF）最短作业优先算法是一种非抢占式调度算法，它根据任务的执行时间来进行排序。
实验中，我们将任务按照执行时间从短到长进行排序，并进行调度。
实验结果显示，SJF算法的优点是能够最大程度地减少平均等待时间，但当任务的执行时间无法预测时，该算法可能会导致长任务等待时间过长的问题。
三、时间片轮转算法（RR）时间片轮转算法是一种抢占式调度算法，它将任务分为多个时间片，并按照顺序进行调度。
实验中，我们设置了每个时间片的长度，并将任务按照到达顺序进行调度。
实验结果表明，RR算法的优点是能够公平地分配资源，但当任务的执行时间超过一个时间片时，会导致上下文切换频繁，影响系统的性能。
四、最高响应比优先算法（HRRN）最高响应比优先算法是一种动态调度算法，它根据任务的等待时间和执行时间来计算响应比，并选择响应比最高的任务进行调度。
实验中，我们根据任务的到达时间、执行时间和等待时间计算响应比，并进行调度。
实验结果显示，HRRN算法能够在一定程度上平衡长任务和短任务的等待时间，但当任务的执行时间过长时，会导致其他任务的等待时间过长。
五、多级反馈队列算法（MFQ）多级反馈队列算法是一种综合性的调度算法，它将任务分为多个队列，并根据任务的执行情况进行调度。
实验中，我们设置了多个队列，并根据任务的执行时间和等待时间进行调度。
多机调度问题报告
湖南涉外经济学院计算机科学与技术专业《算法设计与分析》课程多机调度问题实验报告班级：计科 1 0 0 2学号：***************姓名：教师：成绩：2012年5月【实验目的】1 掌握贪心算法2 利用贪心算法解决多机调度问题3 分析实验结果，是否能将机器处理时间最短化【系统环境】Windows 7 平台【实验工具】VC++6.0英文企业版【问题描述】描述：设有n个独立的作业{1,2，…，n}，由m台相同的机器进行加工处理。
作业i所需的处理时间为t。
现约定，任何作业可以在任何一台机器上加工处理，但未完工前不允许中断处理。
任何作业不能拆分成更小的子作业。
多机调度问题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
例：设7个独立作业{1,2,3,4,5,6,7}有3台机器m1，m2，m3来加工处理。
各作业所需的处理时间分别为{2,14,4,16,6,5,3}。
现要求用贪心算法给出最优解。
【实验原理】贪心算法的应用，该算法总是做出在当前看来是最好的选择。
也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。
贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。
贪心法基本策略：1、分析问题性质，确定适当的贪心选择标准；2、按贪心选择标准对n个输入进行排序，初始化部分解；3、按序每次输入一个量，如果这个输入和当前已构成在这种选择标准下的部分解加在一起不能产生一个可行解，则此输入不能加入到部分解中，否则形成新的部分解；4、继续处理下一输入，直至n个输入处理完毕，最终的部分解即为此问题的最优解。
【源程序代码】#include<stdio.h>#define N 10typedef struct node{int ID,time;//作业所需时间}jobnode;typedef struct Node{int ID,avail;//ID 机器编号 avail 每次作业的初始时间}manode;manode machine[N];jobnode job[N];/*找出下个作业执行机器*/manode* Find_min(manode a[],int m){manode* temp=&a[0];for(int i=1;i<m;i++){if(a[i].avail<temp->avail)temp=&a[i];}return temp;}/*对作业时间由大到小进行排序*/void Sort(jobnode t[],int n){jobnode temp;for(int i=0;i<n-1;i++)for(int j=n-1;j>i;j--){if(job[j].time>job[j-1].time){temp=job[j];job[j]=job[j-1];job[j-1]=temp;}}}void main(){int n,m,temp,i;manode* ma;printf("输入作业数目(作业编号按输入顺序处理)\n");scanf("%d",&n);printf("输入相应作业所需处理时间:\n");for( i=0;i<n;i++){scanf("%d",&job[i].time);job[i].ID=i+1;}printf("输入机器数目(机器编号按输入顺序处理)\n");scanf("%d",&m);for( i=0;i<m;i++)//给机器进行编号并初始化{machine[i].ID=i+1;machine[i].avail=0;}putchar('\n');if(n<=m){printf("为每个作业分配一台机器,可完成任务!\n");return;}Sort(job,n);for( i=0;i<n;i++){ma=Find_min(machine,m);printf("将机器: M%d 从 %d -----> %d 的时间段分配给作业: %d\n",ma->ID,ma->avail,ma->avail+job[i].time,job[i].ID); ma->avail+=job[i].time;}temp=machine[0].avail;for( i=1;i<m;i++){if(machine[i].avail>temp)temp=machine[i].avail;}putchar('\n');printf("该批作业处理完成所需加工时间为: %d\n",temp);while (1);}【实验结果】1.输入作业数目2.输入每个作业所需要的处理时间3.输入机器数目4.输出结果。
算法分析与设计实验报告
算法分析与设计实验报告算法分析与设计实验报告一、引言算法是计算机科学的核心，它们是解决问题的有效工具。
算法分析与设计是计算机科学中的重要课题，通过对算法的分析与设计，我们可以优化计算机程序的效率，提高计算机系统的性能。
本实验报告旨在介绍算法分析与设计的基本概念和方法，并通过实验验证这些方法的有效性。
二、算法分析算法分析是评估算法性能的过程。
在实际应用中，我们常常需要比较不同算法的效率和资源消耗，以选择最适合的算法。
常用的算法分析方法包括时间复杂度和空间复杂度。
1. 时间复杂度时间复杂度衡量了算法执行所需的时间。
通常用大O表示法表示时间复杂度，表示算法的最坏情况下的运行时间。
常见的时间复杂度有O(1)、O(log n)、O(n)、O(n log n)和O(n^2)等。
其中，O(1)表示常数时间复杂度，O(log n)表示对数时间复杂度，O(n)表示线性时间复杂度，O(n log n)表示线性对数时间复杂度，O(n^2)表示平方时间复杂度。
2. 空间复杂度空间复杂度衡量了算法执行所需的存储空间。
通常用大O表示法表示空间复杂度，表示算法所需的额外存储空间。
常见的空间复杂度有O(1)、O(n)和O(n^2)等。
其中，O(1)表示常数空间复杂度，O(n)表示线性空间复杂度，O(n^2)表示平方空间复杂度。
三、算法设计算法设计是构思和实现算法的过程。
好的算法设计能够提高算法的效率和可靠性。
常用的算法设计方法包括贪心算法、动态规划、分治法和回溯法等。
1. 贪心算法贪心算法是一种简单而高效的算法设计方法。
它通过每一步选择局部最优解，最终得到全局最优解。
贪心算法的时间复杂度通常较低，但不能保证得到最优解。
2. 动态规划动态规划是一种将问题分解为子问题并以自底向上的方式求解的算法设计方法。
它通过保存子问题的解，避免重复计算，提高算法的效率。
动态规划适用于具有重叠子问题和最优子结构的问题。
3. 分治法分治法是一种将问题分解为更小规模的子问题并以递归的方式求解的算法设计方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
算法设计实验报告题目：独立任务最优调度问题
年月日
一、实验题目
独立任务最优调度问题
二、实验目的
问题描述：用2 台处理机A和B处理n个作业。
设第i个作业交给机器A 处理时需要时间a i，若由机器B来处理，则需要时间b i。
由于各作业的特点和机
器的性能关系，很可能对于某些i，有a i=>b i，而对于某些 j，j≠i，有a j<b j。
既不能将一个作业分开由 2 台机器处理，也没有一台机器能同时处理2 个作业。
设计一个动态规划算法，使得这2台机器处理完这n个作业的时间最短(从任何一台机器开工到最后一台机器停工的总时间)。
研究一个实例：(a1,a2,a3,a4,a5,a6)＝(2,5,7,10,5,2)；(b1,b2,b3,b4,b5,b6)＝(3,8,4,11,3,4)。
三、实验内容
算法设计：对于给定的两台处理机A和B处理n个作业，找出一个最优调度方案使两台机器处理完这n个作业的时间最短。
数据输入：由文件input.txt提供输入数据。
文件的第一行是一个正整数n，表示要处理n个作业。
在接下来的2行中，每行n个正整数，分别表示处理机A和B处理第个作业需要的处理时间。
结果输出:将计算出的最短处理时间输出到文件output.txt。
输入文件示例输出文件示例
input.txt output.txt
6 15
2 5 7 10 5 2
3 8
4 11 3 4
四、实验原理
首先要注意每个作业仅需要处理一次就行，不需要被机器A和B各处理一遍
采用动态规划;定义t[i][j]为：表示完成i个作业且机器A花费j时间的条件下机器B所花费时间的最小值，那么t[i][j] = min{t[i-1][j] + b[i], t[i-1][j-a[i]]}。
假设前i-1件已经被处理了，那么第 i 件作业由谁来处理可以分两种情况：
1）由机器A处理i，则机器B的时间为 t[i-1][j-a[i]];
2）由机器B处理i，则机器B的时间为 t[i-1][j]+b[i];
3）特殊情况，如果j < a[i],则不可能由机器A来完成，此时t[i][j] = t[i-1][j]+b[i]；
最终t[i][j] 选择1）和2）中较小的一个，即t[i][j] = min{t[i-
1][j]+b[i], t[i-1][j-a[i]]}。
五、实验步骤
1）实验环境：Microsoft Visual Studio 2010
2）编写代码，在程序文件夹下建立input.txt，output.txt，输入题目，不断调试运行。
3）实验代码
#include<stdio.h>
#define N 100
int main()
{
int i,j,n;
int sum=0;
int a[N]={0},b[N]={0},t[N][N]={0};
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
scanf("%d",&n);
for(i=0;i<n;i++) {
scanf("%d",&a[i]);
sum+=a[i];
}
for(j=0;j<n;j++) {
scanf("%d",&b[j]);
}
for(i=1;i<=n;i++) {
for(j=0;j<=sum;j++) {
if(j<a[i-1]) //此时交给B
t[i][j]=t[i-1][j]+b[i-1];
else if(t[i-1][j-a[i-1]]>t[i-1][j]+b[i-1])
t[i][j]=t[i-1][j]+b[i-1];
else
t[i][j]=t[i-1][j-a[i-1]];
}
}
int min=1000000;
for(i=0;i<=sum;i++) {
j=t[n][i]>i?t[n][i]:i;
if(min>j) {
min=j;
}
}
printf("%d\n",min);
return 0;
}
六、实验结果分析
本次实验采用动态规划法完成，由于两机器可以同时工作，A的运行对B的运行没有影响，确定了第i件任务由谁来完成，B花的时间最短，然后再从A和B中取得最晚的停机时间，就可以确定A和B完成任务的最短时间。
所以问题满足最优子结构性质。
算法复杂度：由于对于每个任务，需要遍历A所花的所有时间，设任务有n
个，A花费时间总和为m，计算t[i][j]花费的时间为常数级别，所以时间复杂度为O(nm),空间复杂度就是一个二维数组nm。
运行结果如下：。