作业调度快速贪心算法
贪心法 多机调度问题
//多机调度问题/*贪心法求解多级调度问题的贪心策略师最长处理时间的作业优先，即把处理时间最长的作业分配给最先空闲的机器，这样就可以保证处理时间长的作业优先处理，从而在整体上获得尽可能短的时间。
按照最长处理时间作业优先的贪心测落，当m>n,时，只要将机器ide [0,ti)时间去见分配给作业j即可，当m<n时，首先将n个作业从大到小排序，然后依次顺序将作业分配给空闲的处理机算法伪代码将数组t[n]从大到小排序，对应的作业序号存储在数组p[n]中；将数组d[m]初始化为零3：for（i0;i<=m;i++)3.1:s[i]={p[i]}:将m个作业分配给m个机器3.2 d[i]=t[i];for(i=m+1;i<=n;i++)4.1 j=数组d[m]中最小值对应的下标；//j为最先空闲的机器序号4.2 s[j]=s[j]+{p[i]};//将作业分配给最先空闲的的机器j4.3 d[j]=d[j]+d[t];//机器j将在d[j]后空闲*/#include<iostream>using namespace std;void lowsort(int *t,int *p,int n)//将数组t[n]按从小到大的顺序排序，相应的任务编号数组p[n]也要随之改变{int index;for(int i=0;i<n;i++){index=i;for(int j=i+1;j<n;j++){if(t[index]<t[j])index=j;}if(index!=i){int temp;temp=t[index];t[index]=t[i];t[i]=temp;temp=p[i];p[i]=p[index];p[index]=temp;}}int find(int *d,int m){int min=d[0];int k;for(int i=0;i<m;i++){if(d[i]<min){min=d[i];k=i;}}return k;}void ajust(int *t,int *d,int *p,int *s,int n,int m){lowsort(t,p,n);for(int i=0;i<m;i++){d[m]=0;}for(i=0;i<m;i++){s[i]=p[i];cout<<"机器"<<i+1<<"做了任务"<<p[i]<<endl;d[i]=t[i];}for(i=m;i<n;i++){int j=find(d,m);//查找数组d[m]中最小值对应的下标s[j]=s[j]+p[i];cout<<"机器"<<j+1<<"做了任务"<<p[i]<<endl;d[j]=d[j]+t[i];}}void main()int n,m;cout<<"输入任务数量"<<endl;cin>>n;cout<<"输入机器个数"<<endl;cin>>m;int *t=new int [n];int *s=new int [n];int *d=new int [m];int *p=new int[n];cout<<"输入任务编号"<<endl;for(int k=0;k<n;k++)cin>>p[k];cout<<"每件任务所花费的时间"<<endl;for(int i=0;i<n;i++)cin>>t[i];ajust(t,d,p,s,n,m);}。
贪心算法的基本原理
贪心算法的基本原理贪心算法（Greedy Algorithm）是一种常用的算法思想，它在求解最优化问题时通常能够得到较好的近似解。
贪心算法的基本原理是：每一步都选择当前状态下的最优解，从而希望最终能够得到全局最优解。
在实际应用中，贪心算法常常用于解决一些最优化问题，如最小生成树、最短路径、任务调度等。
一、贪心算法的特点贪心算法具有以下特点：1. 简单：贪心算法通常比较简单，易于实现和理解。
2. 高效：贪心算法的时间复杂度通常较低，能够在较短的时间内得到结果。
3. 局部最优：每一步都选择当前状态下的最优解，但不能保证最终能够得到全局最优解。
4. 适用范围：贪心算法适用于一些特定类型的问题，如无后效性、最优子结构等。
二、贪心算法的基本原理贪心算法的基本原理可以概括为以下几个步骤：1. 初始状态：确定问题的初始状态，定义问题的输入和输出。
2. 状态转移：根据当前状态，选择局部最优解，并更新状态。
3. 筛选解：判断当前状态下是否满足问题的约束条件，若满足则保留该解，否则舍弃。
4. 终止条件：重复以上步骤，直至满足终止条件，得到最终解。
三、贪心算法的应用举例1. 找零钱：假设有 25、10、5、1 四种面额的硬币，需要找零 41 元，如何使得找零的硬币数量最少？贪心算法可以先选择面额最大的硬币，然后逐步选择面额较小的硬币，直至找零完毕。
2. 区间调度：给定一组区间，如何选择最多的互不重叠的区间？贪心算法可以先按照区间的结束时间排序，然后依次选择结束时间最早的区间，直至所有区间都被覆盖。
3. 最小生成树：在一个连通的带权无向图中，如何选择边使得生成树的权值最小？贪心算法可以按照边的权值从小到大排序，然后依次选择权值最小且不构成环的边，直至所有顶点都被连接。
四、贪心算法的优缺点1. 优点：贪心算法简单高效，适用于一些特定类型的问题，能够在较短的时间内得到近似最优解。
2. 缺点：贪心算法不能保证一定能够得到全局最优解，可能会出现局部最优解不是全局最优解的情况。
贪心算法在优化问题中的运用
贪心算法在优化问题中的运用贪心算法（Greedy Algorithm）是一种常用的算法思想，它在解决一些优化问题时具有很高的效率和实用性。
贪心算法的核心思想是每一步都选择当前状态下最优的解决方案，以期望最终能够得到全局最优解。
在实际应用中，贪心算法常常被用来解决一些最优化问题，如最短路径问题、背包问题、任务调度等。
本文将介绍贪心算法在优化问题中的运用，并通过具体案例来说明其应用场景和解决方法。
一、贪心算法的基本原理贪心算法是一种在每一步选择当前状态下最优解决方案的算法思想。
它与动态规划不同，贪心算法并不会保存之前的计算结果，而是根据当前状态做出最优选择。
贪心算法的优势在于简单、高效，适用于一些特定类型的问题。
贪心算法的基本原理可以总结为以下几点：1. 每一步都选择当前状态下的最优解决方案；2. 不考虑未来的结果，只关注当前状态的最优选择；3. 最终期望通过每一步的最优选择达到全局最优解。
二、贪心算法在优化问题中的应用1. 最短路径问题最短路径问题是图论中的经典问题，贪心算法可以用来解决一些简单的最短路径问题。
例如，在无权图中，从起点到终点的最短路径可以通过贪心算法来求解，每次选择距离最近的节点作为下一步的目标节点，直到到达终点为止。
2. 背包问题背包问题是一个经典的优化问题，贪心算法可以用来解决一些特定类型的背包问题。
例如，在分数背包问题中，每种物品可以取任意比例，贪心算法可以按照单位价值最高的顺序选择物品放入背包，直到背包装满为止。
3. 任务调度问题任务调度问题是一个常见的优化问题，贪心算法可以用来解决一些简单的任务调度问题。
例如，在单处理器任务调度中，每个任务有一个开始时间和结束时间，贪心算法可以按照结束时间的先后顺序对任务进行调度，以最大化处理器的利用率。
三、案例分析：活动选择问题活动选择问题是一个经典的优化问题，通过贪心算法可以高效地解决。
问题描述如下：假设有n个活动，每个活动都有一个开始时间和结束时间，活动之间不能交叉进行，问如何安排活动才能使参加的活动数量最多。
贪心算法---例题5.多机调度问题
cout<<"("<<x.first<<","<<x.second<<")"<<endl; } int timeTotal = 0; vector<int> timeOfMachine(n, 0); int pos = 0; //表示Job数组的下标 while(m--) {
int minPosition = min_element(timeOfMachine.begin(), timeOfMachine.end()) - timeOfMachine.begin(); timeOfMachine[minPosition] += Job[pos].second; cout<<"将作业"<<Job[pos].first<<"分配给机器"<<minPosition+1<<",用时"<<Job[pos].second; cout<<"机器"<<minPosition+1<<"目前总用时为"<<timeOfMachine[minPosition]<<endl; pos++; } return *max_element(timeOfMachine.begin(), timeOfMachine.end()); } int main() { cout<<"一共m个作业,请输入m: "; int m; cin>>m; cout<<"请输入每个作业的时间: "<<endl; vector<pair<int, int>> Job; int time; for(int i=0; i<m; i++) { cin>>time; Job.push_back(pair<int, int>(i+1, time)); } cout<<"指定n台机器,请输入n: "<<endl; int n; cin>>n; int timeTotal = JobSort(Job, n); cout<<"总用时为: "<<timeTotal<<endl; system("pause"); return 0; }
贪心算法知识点总结
贪心算法知识点总结1. 基本原理贪心算法的基本原理是每一步都选择当前状态下的最优解，以期望最终得到全局最优解。
具体来说，贪心算法通常可以分为以下几个步骤：1）从问题的某个初始解出发2）采用一种迭代的方式，逐步将初始解进行优化3）每一步都是基于当前状态的最优选择来进行优化4）直到无法再进行优化，得到问题的最优解由于贪心算法每一步都要选择局部最优解，因此贪心算法通常具有高效性。
然而，贪心算法并不适用于所有问题，其结果不一定是全局最优解。
因此，在使用贪心算法时需要注意问题的特性和约束条件，以免得到错误的结果。
2. 适用情况贪心算法通常适用于满足以下条件的问题：1）问题的最优解满足“最优子结构”性质：即问题的最优解包含了其子问题的最优解2）问题的求解过程具有“贪心选择性”：即每一步都选择当前状态下的最优解，并不需要考虑未来的后果3）问题的约束条件可以通过局部最优选择满足全局最优解：即问题的解空间中存在一些局部最优解，可以通过一系列的局部最优解构建全局最优解在实际应用中，贪心算法通常用于求解最优化问题，如最小生成树、最短路径、任务调度等问题。
由于贪心算法的高效性，它通常能够在较短的时间内得到较为接近最优解的结果。
然而，贪心算法并不适用于所有问题，对于一些问题，贪心算法将得到错误的结果。
因此，在使用贪心算法时需要谨慎选择问题类型和约束条件，以避免错误的结果。
3. 贪心算法实例在下面的部分，我们将介绍一些常见的贪心算法实例，包括背包问题、活动安排问题、霍夫曼编码等。
3.1 背包问题背包问题是一个经典的优化问题，它包括0-1背包问题、分数背包问题等多种类型。
在0-1背包问题中，给定n种物品和一个容量为C的背包，每种物品i的重量为w[i]，价值为v[i]，求在不超过背包容量的情况下，如何选择物品放入背包，可以使得背包中的总价值最大。
对于0-1背包问题，贪心算法通常不能得到最优解。
然而，在分数背包问题中，贪心算法通常可以得到近似的最优解。
多机调度问题贪心算法c语言
多机调度问题贪心算法c语言一、引言多机调度问题是指将一组作业分配给多台机器，使得完成所有作业的时间最短。
在实际生产中，多机调度问题是一个常见的优化问题。
贪心算法是解决多机调度问题的一种有效方法。
本文将介绍贪心算法在C语言中的应用。
二、问题描述假设有n个作业需要分配给m台机器进行加工处理，每个作业需要的时间不同，每台机器的处理速度也不同。
现在需要设计一个算法，将这些作业分配给这些机器进行加工处理，并使得完成所有作业所需时间最短。
三、贪心算法思路贪心算法是一种基于局部最优解来构造全局最优解的思想。
对于多机调度问题，我们可以采用以下贪心策略：1. 将所有作业按照所需时间从大到小排序；2. 将第一个作业分配给第一台机器；3. 对于剩余的作业，选择当前处理时间最短的那台机器进行分配；4. 重复步骤3直到所有作业都被分配完毕。
四、C语言实现下面是C语言实现多机调度问题贪心算法的代码：#include <stdio.h>#include <stdlib.h>#define MAX_JOB 1000#define MAX_MACHINE 1000int cmp(const void *a, const void *b) {return *(int *)b - *(int *)a;}int main() {int n, m, job[MAX_JOB], machine[MAX_MACHINE] = {0}; scanf("%d%d", &n, &m);for (int i = 0; i < n; i++) {scanf("%d", &job[i]);}qsort(job, n, sizeof(int), cmp);for (int i = 0; i < n; i++) {int min_time = machine[0], min_index = 0;for (int j = 1; j < m; j++) {if (machine[j] < min_time) { min_time = machine[j]; min_index = j;}}machine[min_index] += job[i]; }int max_time = machine[0];for (int i = 1; i < m; i++) {if (machine[i] > max_time) { max_time = machine[i];}}printf("%d\n", max_time);return 0;}五、代码解析1. 宏定义和头文件引入：```#define MAX_JOB 1000#define MAX_MACHINE 1000#include <stdio.h>#include <stdlib.h>```定义了最大作业数和最大机器数，并引入了标准输入输出库和标准库。
贪心算法—多机调度
贪心算法-多机调度一、问题描述设有n个独立的作业，由m台机器进行加工处理，作业i所需的处理时间为t（i）。
约定，任何作业可以在任何机器上加工处理，但未完成前不允许中断处理。
任何作业不能拆分成更小的子作业。
多机调度问题要求给出一种作业调度方案，使n个作业在尽可能短的时间内完成。
二、算法分析1当n<=m时，将机器i的【0~t(i)】时间分配给作业i即可。
2当n>m时，首先将n个作业按照时间从大到小排列。
然后照此顺序将作业分配给空闲的处理机即可。
3创建3个类:JobNode类,MachineNode类, MinHeap类分别用于作业信息，机器信息，对机器类型的堆处理三、代码#include<iostream>using namespace std;#define Max 15template <class Type>class MinHeap{public:MinHeap(int ms);~MinHeap();void Insert(const Type& x);void DeleteMin(Type& x);protected:void FilterDown();//自顶向下构造堆void FilterUp();//自底向上构造堆private:Type *heap;int length;};////////////////////////////////////////template <class Type>MinHeap<Type>::MinHeap(int m){heap=new Type[m+1];length=0;}////////////////////////////////////////template <class Type>void MinHeap<Type>::Insert(const Type& x) {heap[++length]=x;FilterUp();}////////////////////////////////////////template <class Type> template <class Type>void MinHeap<Type>::FilterUp(){//自底向上进行调整int i=length,j=i/2;//父节点的编号Type temp=heap[i];while(i>1){if(temp>=heap[j])break;//找到了相应的位置else{heap[i]=heap[j];i=j;j=i/2;}}heap[i]=temp;}////////////////////////////////////////template <class Type>void MinHeap<Type>::DeleteMin(Type &x){x=heap[1];heap[1]=heap[length];length--;FilterDown();}////////////////////////////////////////template <class Type>void MinHeap<Type>::FilterDown(){int i=1,j=i*2;Type temp=heap[i];while(j<=length){if(j<length && heap[j]>heap[j+1])j++;//如果左右子树都存在,找出最小者,用j标记if(temp<heap[j])break;//找到了相应的位置else{heap[i]=heap[j];i=j;j=2*i;}}heap[i]=temp;}////////////////////////////////////////template <class Type>MinHeap<Type>::~MinHeap(){delete[] heap;}////////////////////////////////////////class JobNode{friend void Greedy(JobNode *,int ,int);friend void main(void);public:operator int() const {return time;}int ID,time;};class MachineNode{friend void Greedy(JobNode *,int ,int); public:operator int() const {return avail;}int ID,avail;};void Sort(JobNode a[],int n){int i,j,k;JobNode tmp;for(i=1;i<n;i++){k=i;for(j=i+1;j<=n;j++){if(a[j].time<a[k].time) k=j;}if(k!=i){tmp=a[i];a[i]=a[k];a[k]=tmp;}}}void Greedy(JobNode a[],int n,int m){if(n<=m){cout<<"为每个作业分配一台机器."<<endl;return;}Sort(a,n);MinHeap<MachineNode>H(m);MachineNode x;for(int i=1;i<=m;i++){x.avail=0;x.ID=i;H.Insert(x);}for(i=n;i>=1;i--){H.DeleteMin(x);cout<<"\n将机器"<<x.ID<<"从"<<x.avail<<"到"<<(x.avail+a[i].time)<<"的时间段分配给作业"<<a[i].ID<<endl;x.avail+=a[i].time;H.Insert(x);}}void main(){int i;int job_cnt; //作业的数目float machine_cnt;//机器数目int Time_of_all=0;JobNode a[Max];//作业所需要的时间// MachineNode b[Max];cout<<"==========多机调度问题===========\n";cout<<"输入机器个数：";cin>>machine_cnt;cout<<"输入作业个数(小于15)：";cin>>job_cnt;for(i=1;i<=job_cnt;i++){cout<<"\n请输入第"<<i<<"个作业处理时间:";cin>>a[i].time;a[i].ID=i;}Greedy(a,job_cnt,machine_cnt);}四、结果截图五．实验总结多机调度问题是生活中比较典型的例子，根据经验我们很好确定贪心算法的贪心标准，但是落实到编程，还是有点不够得心应手，还需要加强自己的编程能力。
多机调度问题的贪心算法实现(使用C语言)
多机调度问题的贪心算法实现（使用C语言）标题：多机调度问题的贪心算法实现（使用C语言）简介：多机调度问题是一个经典的组合优化问题，旨在将一组待处理的任务分配给多台计算机，使得任务完成时间最小化。
贪心算法是一种常用的解决该问题的方法，本文将介绍如何使用C语言实现贪心算法来解决多机调度问题。
引言：随着计算机技术的不断进步，我们面临的任务越来越多，如何有效地将任务分配给多台计算机成为一个重要的问题。
多机调度问题涉及到任务的分配、计算机资源的利用率以及任务完成时间的优化。
本文将通过贪心算法来解决这一问题，贪心算法通过每次选择局部最优解，最终得到一个全局最优解。
1. 多机调度问题的贪心算法概述1.1 贪心算法的基本思想1.2 多机调度问题的贪心策略选择1.3 贪心算法实现的步骤2. 多机调度问题的输入与输出2.1 输入：任务集合和计算机集合2.2 输出：任务分配结果和任务完成时间3. 多机调度问题的贪心算法实现3.1 任务排序3.2 计算机选择3.3 任务分配3.4 计算任务完成时间4. 多机调度问题的贪心算法代码实现（使用C语言） 4.1 数据结构定义4.2 输入模块4.3 贪心算法实现函数4.4 输出模块5. 算法性能分析和改进5.1 算法的时间复杂度分析5.2 算法的空间复杂度分析5.3 改进思路：局部搜索算法的引入6. 总结与展望6.1 对多机调度问题贪心算法的观点和理解6.2 对未来算法改进的展望结论：本文详细介绍了如何使用C语言实现贪心算法来解决多机调度问题。
贪心算法通过选择局部最优解，使得任务完成时间最小化。
此外，我们还讨论了算法的性能分析和改进方向，展望了未来对算法的进一步优化。
通过本文的学习，读者能够更加全面深刻地理解多机调度问题及贪心算法的应用。
参考文献：[1] 文献1[2] 文献2[3] 文献3。
资源调度中的贪心算法实现与优化
资源调度中的贪心算法实现与优化资源调度是指将系统资源合理地分配给各个任务或作业，使得系统能够以高效、公平和可靠的方式运行。
贪心算法是一种常用的资源调度算法，其思想是在每一步选择当前最优的解决方案，以期望最终获得全局最优解。
在资源调度中的贪心算法实现与优化方面，可以从以下几个方面进行讨论和探究。
1.贪心算法的基本实现方法：贪心算法的基本实现方法是从问题的其中一初始解出发，逐步将这个解修改为更好的解，直到无法进行改进为止。
贪心算法每一步的选择都依赖于当前的局部最优解，并且不能回退。
在资源调度中，可以将每个任务或作业看作是贪心算法的一个决策节点，通过在每个节点选择当前最优解的方式来进行资源调度。
2.贪心算法的优化策略：贪心算法在实际应用中可能面临多个冲突的选择，导致最终结果不一定是全局最优解。
为了优化贪心算法的效果，可以采用以下几种策略：a.加入限制条件：在贪心选择的过程中，引入一些限制条件，以保证每次选择的局部最优解符合全局最优解的要求。
b.引入启发式规则：根据问题的特殊性，设计一些启发式规则来指导贪心算法的选择，从而提高算法的效率和质量。
c.重置策略：当出现由于贪心选择引起的不满足要求的情况时，可以通过重置算法的策略来修复之前的决策，并重新进行资源调度。
d.多步策略：在每一步选择中，可以考虑多个决策节点，通过综合考量每个决策节点的优劣，并选择其中最优的决策。
3.实例分析：以任务调度为例，说明贪心算法的实现与优化。
假设有n个任务需要在给定的时间段内完成，每个任务有一个开始时间和结束时间。
资源调度的目标是尽可能多地完成任务。
可以使用贪心算法来实现任务调度，具体步骤如下：a.将所有任务按照结束时间从早到晚排序。
b.选择第一个任务，并标记为已完成。
c.从第二个任务开始，如果该任务的开始时间大于等于上一个任务的结束时间，则选择该任务，并标记为已完成。
d.重复步骤c，直到所有任务都完成。
这个算法的时间复杂度为O(nlogn)，其中n为任务的数量。
云计算中融入贪心策略的调度算法研究
云计算中融入贪心策略的调度算法研究云计算是一种新兴的计算模式，已经成为当今计算领域的热门话题。
云计算具有高效、灵活、安全、可靠等优点，深受企业和个人用户的青睐，已成为大数据、人工智能等领域的核心技术。
然而，在云计算应用中，调度算法是一个非常关键的问题。
如何优化云计算资源的利用效率，提高云计算平台的性能，是云计算研究的重要课题之一。
云计算中的融入贪心策略的调度算法，是近年来研究的热点之一。
贪心算法是一种基于贪心思想的算法，它总是做出当前看来最优的选择。
云计算中的调度问题本质上是资源分配问题，需要合理的分配计算、存储、网络等资源，以最大化利润或最小化成本。
基于贪心思想的调度算法，可以有效地解决云计算中的任务分配和资源分配问题，提高资源利用率和平台性能。
在云计算中，任务分配和资源分配是两个重要的问题。
任务分配就是将用户提交的任务分配到云计算平台中的多个计算节点中执行。
在这个过程中，需要考虑到不同任务的数据量、执行时间、优先级等因素，以及计算资源的状态、类型、数量等。
在分配任务时，采用贪心算法可以使分配过程更加高效简单。
例如，可以采用最短作业优先（SJF）算法，对任务进行排序，并按照顺序分配资源。
这样可以有效地减少系统开销和能量消耗，提高计算平台的效率。
资源分配是指将计算、存储、网络等资源合理地分配到不同的计算节点中，以满足用户需求，提高平台性能。
在资源分配过程中，需要考虑到不同任务的资源要求、任务的优先级以及节点间的带宽、延迟等因素。
采用贪心算法可以使资源分配更加高效和灵活。
例如，可以采用最大利用率优先（MUP）算法，对节点进行排序，并按照顺序分配资源。
这样可以最大化利用计算资源，提高系统的整体性能。
需要注意的是，贪心算法具有局限性。
在实际应用中，贪心算法的效果很大程度上取决于问题的特点和算法的实现。
对于某些问题而言，贪心算法可能不是最优解，甚至可能会导致局部最优解而无法到达全局最优解。
因此，在使用贪心算法进行任务分配和资源分配时，需要结合实际情况，适当地调整算法参数和策略，使得算法更加可靠和稳健。
贪婪算法(例题及相关解答)
第 1 章贪婪算法虽然设计一个好的求解算法更像是一门艺术，而不像是技术，但仍然存在一些行之有效的能够用于解决许多问题的算法设计方法，你可以使用这些方法来设计算法，并观察这些算法是如何工作的。
一般情况下，为了获得较好的性能，必须对算法进行细致的调整。
但是在某些情况下，算法经过调整之后性能仍无法达到要求，这时就必须寻求另外的方法来求解该问题。
本章首先引入最优化的概念，然后介绍一种直观的问题求解方法：贪婪算法。
最后，应用该算法给出货箱装船问题、背包问题、拓扑排序问题、二分覆盖问题、最短路径问题、最小代价生成树等问题的求解方案。
1.1 最优化问题本章及后续章节中的许多例子都是最优化问题（ optimization problem），每个最优化问题都包含一组限制条件（ c o n s t r a i n t）和一个优化函数（ optimization function），符合限制条件的问题求解方案称为可行解（feasible solution），使优化函数取得最佳值的可行解称为最优解（optimal solution）。
例1-1 [ 渴婴问题] 有一个非常渴的、聪明的小婴儿，她可能得到的东西包括一杯水、一桶牛奶、多罐不同种类的果汁、许多不同的装在瓶子或罐子中的苏打水，即婴儿可得到n 种不同的饮料。
根据以前关于这n 种饮料的不同体验，此婴儿知道这其中某些饮料更合自己的胃口，因此，婴儿采取如下方法为每一种饮料赋予一个满意度值：饮用1盎司第i 种饮料，对它作出相对评价，将一个数值s i 作为满意度赋予第i 种饮料。
通常，这个婴儿都会尽量饮用具有最大满意度值的饮料来最大限度地满足她解渴的需要，但是不幸的是：具有最大满意度值的饮料有时并没有足够的量来满足此婴儿解渴的需要。
设a i是第i 种饮料的总量（以盎司为单位），而此婴儿需要t 盎司的饮料来解渴，那么，需要饮用n种不同的饮料各多少量才能满足婴儿解渴的需求呢？设各种饮料的满意度已知。
贪心算法求解多机调度问题
多机调度问题一、 问题描述设有n个独立的作业{1,2,…,n}，由m台相同的机器进行加工处理。
作业i所需的处理时间为t i。
现约定，任何作业可以在任何一台机器上加工处理，但未完工前不允许中断处理，任何作业不能拆分成更小的子作业。
要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
二、 问题分析这是一个NP完全问题，到目前为止还没有有效的解法。
本报告根据教材指导及实践经验，采用贪心算法进行分析求解，并进行简单评估。
使用贪心算法，能避免许多复杂的子问题分析，便于直观地剖析主要问题。
在选择贪心算法的基础上，进一步地，我们采用最长处理时间作业优先的贪心选择策略，以求设计出解多机调度问题的较好的近似算法。
预期效果：根据最长处理时间作业优先的原则，理应能够得出直观下比较高效的输出结果。
三、算法设计与分析1．算法输入和输出输入：作业数n，机器数m，作业i对应的处理时间t i（t i在测试时用一个一维数组time表示）输出：总耗费时间2．算法说明最长处理时间作业优先的贪心算法，顾名思义，就是将目前还未被处理的且需要处理时间最长的作业，分配给最先空闲的机器，直到分配完所有的作业为止。
3．算法描述（1）（处理1）：当n≤m时，只要将机器i的[0,t i]时间区间分配给作业i即可。
（2）（处理2）：当n＞m时：i.先将耗时最长的m个作业依次分配给m个机器ii.沿着时间轴，寻找最先得到空闲的机器。
将还未被处理且需要处理时间最长的那个作业分配给此机器iii.重复上一步直到所有作业都被处理完毕4．算法分析当n≤m时，算法需要O(1)时间。
当n＞m时，算法需要O(nlogn)时间。
四、算法流程图输入是否n≤m处理1 处理2输出图4-1 多机调度算法流程图五、测试数据及其结果分析1．测试数据当输入n=7, m=3, time={2,14,4,16,6,5,3}时（教材示例），经历处理2，输出结果为17 当输入n=7, m=3, time={4,5,13,9,4,11,2}时，经历处理2，输出结果为20当输入n=18, m=3, time={1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9}时，经历处理2，输出结果为33当输入n=3, m=3, time={2,3,5}时，经历处理1，输出结果为52．结果分析观察可知，贪心算法解此问题，比直观感受要更高效。
作业调度贪心算法
软件算法设计实验报告题目：作业调度问题院(系)：计算机科学与工程专业：班级：学生：学号：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 2 3 4 5 6 7时间214416653序号 4 2 5 6 3 7 1时间161465432假设有三台机器，建立最小堆算法实现:1.运行环境：Myeclipse 8.5 java project2.源代码：//基于最小堆的贪心算法解多机调度问题,//heapsort on minheapimport java.io.*;class MinHeap{ //Min-heap impmentationstatic jobNode[] Heap; //Pointer to the heap arraystatic int size; //Maximum size of the heapstatic int n; //Number of intents now in heapheapsoetpublic 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<n);}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 pospublic static int leftchild(int pos){ Assert_notFalse(pos<n/2,"position has no left child");return 2*pos+1;}//return position for right child of pospublic 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<n),"illegal heap position ");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 valueif(Heap[pos].key()<=Heap[j].key()) return;// Doneswap(Heap,pos,j);pos=j; } //Move down}public static void insert(jobNode val) //Insert value into heap{Assert_notFalse(n<size,"Heap is full ");int curr=n++;Heap[curr]=val; //start t end of heap//Now sift up until curr's parent's key<curr's keywhile(curr!=0 && Heap[curr].key()<Heap[parent(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 valueif(n!=0) //Not on last intentsiftdown(0); //Put new heap root val in corrent placereturn Heap[n];} //Remove intent at specified positionpublic static jobNode remove(int pos){Assert_notFalse((pos>0)&&(pos<n),"illegal heap position ");swap(Heap,pos,--n);//swap with last valueif(n!=0) //Not on last intentsiftdown(pos);//put new heap root val in corrent placereturn 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<size-1;i++) //now sortSystem.out.print(removemin()+" ");System.out.println( ); //removemin places min value at end of heap }}// class MinHeapclass 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<xt)return -1;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<right){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];elsefor(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<m){for(int i=0;i<=n1;i++)if(sum<a[i])sum=a[i];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<m;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) 时间。
约翰逊算法例题
约翰逊算法例题约翰逊算法（Johnson's Algorithm）是一种用于解决两台机器上的作业调度问题的贪心算法。
该算法可以将作业按照最优顺序安排在两台机器上，使得完成所有作业的时间最短。
以下是一个约翰逊算法的例题：假设有4个作业（A、B、C、D）需要在两台机器上完成。
每个作业在两台机器上的处理时间如下表所示：作业| 机器1处理时间| 机器2处理时间--- | --- | ---A | 3 | 6B | 2 | 5C | 4 | 3D | 2 | 2按照约翰逊算法的步骤来解决这个问题：步骤1：计算作业在机器1上的处理时间和在机器2上的处理时间之和，并按照总时间从小到大排序。
作业| 机器1处理时间| 机器2处理时间| 总时间--- | --- | --- | ---B | 2 | 5 | 7D | 2 | 2 | 4C | 4 | 3 | 7A | 3 | 6 | 9按照总时间的大小顺序重新排列作业：D、B、C、A步骤2：从总时间最小的作业开始，依次将作业分配给机器1和机器2，直到所有作业都被分配完毕。
初始情况下，机器1和机器2都没有被分配作业。
首先，将作业D分配给机器1，将作业D分配给机器2。
此时，机器1的处理时间为2，机器2的处理时间为2。
作业| 分配机器--- | ---D | 1D | 2接下来，将作业B分配给机器1，将作业C分配给机器2。
此时，机器1的处理时间为4，机器2的处理时间为5。
作业| 分配机器--- | ---D | 1D | 2B | 1C | 2最后，将作业A分配给机器1，将作业A分配给机器2。
此时，机器1的处理时间为7，机器2的处理时间为11。
作业| 分配机器--- | ---D | 1D | 2B | 1C | 2A | 1A | 2步骤3：按照作业的分配顺序得到最终的作业调度顺序。
最终的作业调度顺序为：D、B、C、A、A。
因此，按照约翰逊算法，最优的作业调度顺序为：D、B、C、A、A，完成所有作业的总时间为11个单位。
贪心算法：任务调度问题
数据结构课程设计报告贪心算法：任务调度问题专业计算机科学与技术（软件工程）学生姓名陈亮班级BM计算机091学号**********指导教师吴素芹起止日期2011.1.10-2011.1.14***********目录1简介 (1)2算法说明 (2)3测试结果 (2)4分析与探讨 (8)5小结 (11)参考文献 (11)附录 (12)附录1 源程序清单 (12)贪心算法1 简介贪心算法通过一系列的选择来得到一个问题的解。
它所做的每一个选择都是当前状态下某种意义的最好选择，即贪心选择。
希望通过每次所做的贪心选择导致最终结果是问题的一个最优解。
这种启发式的策略并不总奏效，然而许多情况下确能达到预期的目的。
下面来看一个找硬币的例子。
假设有四种面值的硬币：一分、两分、五分和一角。
现在要找给某顾客四角八分钱。
这时，一般都会拿出四个一角、一个五分、一个两分和一个一分的硬币递给顾客。
这种找硬币的方法与其他的方法相比，它所给出的硬币个数是最少的。
在这里，就是下意思的使用了贪心算法（即尽可能地先考虑大币值的硬币）。
贪心算法并不是从整体最优加以考虑，它所做出的选择只是局部最优选择。
一些问题中，使用贪心算法得到的最后结果并不是整体的最优解，这时算法得到的是一次最优解（Suboptimal Solution）。
在上述的问题中，使用贪心算法得到的结果恰好就是问题整体的最优解。
对于一个具体的问题，怎么知道是否可用贪心算法来解此问题，以及能否得到问题的一个最优解呢？这个问题很难给予肯定的回答。
但是，许多可以用贪心算法求解的问题中一般具有两个重要的性质：贪心选择性质和最优子结构性质。
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择即贪心选择来达到，这是贪心算法可行的第一个基本要素。
对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所做的贪心选择最终将会得到问题的一个整体最优解。
首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始。
流水作业调度问题———Johnson算法
流⽔作业调度问题———Johnson算法问题描述：N个作业1，2，…，n要在由2台机器A和B组成的流⽔线上完成加⼯。
每个作业加⼯的顺序都是先在A上加⼯，然后在B上加⼯。
A和B加⼯作业i所需的时间分别为a[i]和b[i]。
你可以安排每个作业的执⾏顺序，使得从第⼀个作业在机器A上开始加⼯，到最后⼀个作业在机器B上加⼯完成所需的时间最少。
求这个最少的时间。
⼤概思路：求⼀个加⼯顺序使得加⼯时间最短，就是让机器空闲时间最短，当A开始⼯作便会⼀直运作，关键是B会等待A，很明显A加⼯第⼀个作业时B得等待，同理B加⼯最后⼀个作业A 得等待Johnson算法此算法是⼀种贪⼼策略：把在A机器上加⼯最快的作业先加⼯，把B机器上加⼯最快的作业放在最后具体实现：设M i=min{a i,b i}将数组M由⼩到⼤排序，然后从第⼀个开始处理，若M i=a i则按顺序排在作业加⼯顺序的前⾯，若M i=b i则按顺序排在后⾯最后排出来的顺序就是最优解算法证明设S={J1,J2,J3····J n}为待加⼯作业排序，T(S,t)为A开始加⼯S中作业，B需t时刻后才能加⼯A加⼯完的作业，这种情况下加⼯完S中作业所需最⼩的时间T(S,t)=min{a i+T(S−{J i},b i+max{t−a i,0})}, J i∈S假设最佳⽅案是先加⼯J i,然后加⼯J j，则有T(S,t)=a i+T(S−{J i},b i+max{t−a i,0})=a i+a j+T(S−{J i,J j},b i+bj+T ij)T ij=b j+max{b i+max{t−a i,0}−a j,0},0}=b i+b j−a i−a j+max{t,a i,a i+a j−b i}若J i和J j调换顺序则：T′(S,t)=a i+a j+T(S−{J i,J j},T ji)T ji=b i+b j−a i−a j+max{t,a j,a i+a j−b j}所以T(S,t)<=T′(S,t),所以有max{t,a i,a i+a j−b i}<=max{t,a j,a i+a j−b j}a i+a j+max{−b i,−a j}<=a i+a j+max{−b j,−a i}（其实2步转化我不太清楚，只是意会了⼀下，如有理解的⿇烦告诉我，感谢）即min{b j,a i}<=min{b i,a j}也就是说J i在J j之前加⼯最优得满⾜上式条件，则a i<=b i,a j或者b j<=b i,a j即在A机器上加⼯时间短的任务优先，⽽在B机器上加⼯时间短的排在后⾯，与具体实现的步骤相符Processing math: 100%。
假设有4个作业j1、j2、j3和j4,到达时间分别为0、1、1和3,运行时间分别为3、3、2和
假设有4个作业j1、j2、j3和j4,到达时间分别为0、1、1和3,运行时间分别为3、3、2和
本文主要介绍四个作业j1、j2、j3和j4的短程调度，根据其到达时
间和运行时间来分析贪婪算法，提出调度问题的解决方案。
一、四个作业j1、j2、j3和j4的短程调度
1. 四个作业的详细参数
以上四个作业的基本参数情况如下表所示：
| 作业 | 到达时间（t） | 运行时间（cpu） |
| :-----: | :-----------: | :------------: |
| j1 | 0 | 3 |
| j2 | 1 | 3 |
| j3 | 1 | 2 |
| j4 | 3 | 2 |
2. 贪婪算法的实施
在贪婪算法的实施，将作业按照到达时间以及运行时间一次进行排序，按照“到达时间先小后大，同到达时间即运行时间先小后大”的原则，
选择到达时间最短且花费cpu时间最短的作业，依次进行调度或运行，即j1，j3，j2，j4.
三、贪婪算法的总结
通过以上分析，可以得出用贪婪算法解决作业调度问题的总结：
1. 对于多个作业问题，可以根据作业的到达时间和运行时间，按照时间的先后顺序进行排序，依次选出最少用时的作业进行调度；
2. 对于每个作业问题，可以采用贪婪算法进行，以期达到最小的花费总时数，即时间的最优利用。
综上所述，用贪婪算法解决作业调度问题非常有效，可以让我们找到最优解，而且算法本身比较容易实现，使用起来效果比较好，可以满足不断变化的条件下多作业的解决方案，特别是多作业间有关联的短程作业调度问题的求解。
课程设计--贪心算法
课程设计--贪心算法数据结构课程设计贪心算法专业软件工程班级B软件121 学号1210701132 学生姓名目录1设计题目 (1)2设计分析 (1)3设计实现 (4)4测试方法 (7)4.1测试目的 (7)4.2 测试输入 (7)4.3 正确输出 (7)4.4 实际输出 (8)5分析与探讨 (8)5.1 测试结果分析 (8)5.2 探讨与改进 (8)6设计小结 (8)1 设计题目有n项任务，要求按顺序执行，并设定第i项任务需要t[i]单位时间。
如果任务完成的顺序为1，2，…，n，那么第i项任务完成的时间为c[i]=t[1]+…+t[i]，平均完成时间（Average Completion Time，ACT）即为（c[1]+…+c[n]）/n。
本题要求找到最小的任务平均时间。
输入要求：输入数据中包含几个测试案例。
每一个案例的第一行给出一个不大于2000000的整数n，接着下面一行开始列出n个非负整数t（t<=1000000000），每个数之间用空格相互隔开，以一个负数来结束输入。
输出要求：对每一个测试案例，打印它的最小平均完成时间，并精确到0.01。
每个案例对应的输出结果都占一行。
若输入某一个案例中任务数目n=0，则对应输出一个空行。
输入例子：44 2 8 1-1表示有四个任务，各自完成需要的时间单位分别是4，2，8，1，第三行输入-1表示结束。
输出例子：要求程序运行后的输出结果为：6.50。
2 设计分析算法是为了求解一个问题需要遵循的，被青春地指定的简单指令的集合。
任何程序基本上都是要用特点的算法来实现的。
算法性能的好坏，直接决定了所实现程序性能的优劣。
贪心算法通过一系列的选择来的得到一个问题的解。
它所做的每一个选择都是当前的状态下某种意义的最好选择，即贪心选择。
希望通过每次所做的贪心选择导致最终结果问题的一个最优解。
这种启发式的策略并不总能奏效，然而在许多情况下能达到预期的目的。
这个题目属于贪心算法应用中的任务调度问题。
贪心算法适用于哪些问题场景
贪心算法适用于哪些问题场景贪心算法是一种在求解问题时总是做出在当前看来是最好选择的算法。
虽然它不一定能得到全局最优解，但在许多特定的问题场景中，却能高效地给出一个较为满意的结果。
以下就来探讨一下贪心算法适用于哪些问题场景。
首先，贪心算法常用于活动安排问题。
假设有一系列活动，每个活动都有开始时间和结束时间。
我们需要在有限的时间内选择尽可能多的活动来参加。
此时，贪心算法的策略可以是每次都选择结束时间最早的活动。
因为这样能为后续可能的活动留出更多的时间，从而有可能安排更多的活动。
例如，有活动 A（开始时间 8:00，结束时间10:00）、B（开始时间 9:00，结束时间 11:00）、C（开始时间 10:30，结束时间 12:00）。
按照贪心算法，先选择 A 活动，然后由于 B 活动与 A 活动时间有冲突，不能选择，接着可以选择 C 活动。
这种情况下，通过贪心选择，能够安排两个活动。
其次，在找零钱问题中，贪心算法也能发挥作用。
比如，当我们需要用最少的硬币找给顾客零钱时，假设我们有 1 元、5 角、1 角的硬币，要找给顾客 17 元。
贪心算法会先尽量选择面值大的硬币，即先选择 1个 1 元硬币，然后选择 1 个 5 角硬币，再选择 2 个 1 角硬币，这样就能用最少的硬币数量找零。
再者，贪心算法在背包问题的某些变种中适用。
比如，在部分背包问题中，物品可以分割，每个物品都有一定的价值和重量。
我们要在背包容量有限的情况下，装入物品使得总价值最大。
此时，贪心算法可以按照物品的单位重量价值（价值/重量）从大到小的顺序来选择装入背包的物品。
例如，有物品 A（价值 100，重量 20）、物品 B（价值 60，重量 10）、物品 C（价值 80，重量 15），背包容量为 25。
按照贪心算法，先计算单位重量价值，A 为 5，B 为 6，C 为 533。
所以先选择 B 物品全部装入，然后选择 C 物品部分装入（10 重量），这样就能使背包内物品的总价值最大。
多机调度问题贪心算法python代码
多机调度问题贪心算法python代码多机调度问题是一种经典的优化问题，它的目标是在多台机器上完成一组任务，使得任务完成时间最短。
贪心算法是求解这个问题的一种有效方法。
贪心算法的基本思想是每次选择当前最优的解决方案，直到达到全局最优解。
在多机调度问题中，我们可以采用以下贪心策略来求解：1. 将所有任务按照完成时间从小到大排序。
2. 将第一个任务分配给第一台机器。
3. 对于剩余的任务，将其分配给当前完成时间最早的机器。
4. 重复步骤3直到所有任务都被分配完毕。
下面是使用Python实现多机调度问题贪心算法的代码：```pythondef schedule(tasks, m):# 按照完成时间从小到大排序tasks.sort(key=lambda x: x[1])# 初始化每台机器的完成时间为0machines = [0] * m# 分配任务for task in tasks:# 找到当前完成时间最早的机器min_time = machines[0]min_machine = 0for i in range(1, m):if machines[i] < min_time:min_time = machines[i]min_machine = i# 将任务分配给该机器并更新其完成时间machines[min_machine] += task[0]# 返回完成时间最晚的机器的完成时间return max(machines)```该代码中，tasks是一个元素为元组的列表，每个元组表示一个任务，第一个元素为任务的处理时间，第二个元素为任务的完成时间。
m表示机器的数量。
我们可以使用以下代码来测试该函数：```pythontasks = [(2, 6), (3, 7), (4, 8), (4, 9), (5, 10)]m = 3print(schedule(tasks, m))```输出结果为：```12```这表示将这些任务分配给3台机器后，完成所有任务需要的最短时间为12。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
作业调度快速贪心算法
班级：08级通信三班学号：14081403173 姓名：阮晨
成绩：分
一、设计目的
1.掌握贪心算法的思想；
2.掌握贪心算法的典型问题，如作业调度问题；
3.进一步多级调度的基本思想和算法设计方法；
4.提高分析与解决问题的能力。
二、设计内容
1．任务描述
1）多段图问题简介
在无资源约束且每个作业可在等量的是时间内完成的作业调度问题中，可以拟定一个最优解的算法，制定如何选择下一个作业的量度标准，使得所选择的下一个作业在这种量度下达到最优。
快速贪心算法利用减少作业移动—分配最晚时间片原则使得作业在最短的时间片内达到最大的效益值。
2）设计任务简介
设计快速贪心算法实现在效益p=(35, 30, 25, 20, 15, 10, 5, 1),时间期限 d=(4, 2, 4, 5, 6, 4, 5, 7)条件下的最大效益，输出作业的调度序列。
2．快速贪心算法的实现过程
已知n=8, p=(35, 30, 25, 20, 15, 10, 5, 1), d=(4, 2, 4, 5, 6, 4, 5, 7)。
设计、编程实现作业调度快速贪心算法, 要求按作业调度顺序输出作业序列。
案例分析：
可用最晚空闲时间片序号数组 F[]。
存储截止期限值为 i 的作业可用的最晚空闲时间片序号。
初始状态:
F[0:k]={0, 1, 2, 3, …, k-1, k},k = min { n, max {dj} }
竞争可用最晚空闲时间片的截止期限值集合 set[0:k]
在树结构表示下, 初值为：
set[0:k]={{0,-1},{1, -1},{2, -1},{3, -1}, …,{k-1, -1},{k, -1}}.
如下表：
3．主要数据类型与变量
struct
{int data; int tag;
}set[8]; /*定义结构体，其tag为树结构的根节点，data为树的元素
值*/
int J[8]={0}; /*将输出序列初始化为8个元素的数组*/
int min(int a,int b); /*找出a,b两数中较小者*/
int max(int array[8]); /*找出数组array中的最大值*/ void uin(int x,int y); /*合并输出序列*/
4.算法或程序模块
FastGreedyJobScheduling(int *d, float *p, int *J, int n)
{ int k=min {n, max {d[i]}}, F[k+1];
ElemType set[k+1];
for (i=0; i<=k; i++) {F[i]=i; set [i]. data=i; set [i]. tag=-1;}
for (j=0; i=1; i<=n; i++)
{ r = find ( min (n, d[i-1]) );
if (F[r]!=0){ J[j++]=i; m=find(F[r]-1); union (m, r); F[r]=F[m]; }
}
}
模块函数：int min(int a,int b);
int max(int array[8]);
int find(int f);
void uin(int x,int y);
三、测试结果。
四、总结与讨论
这次的设计的主要内容是作业调度快速贪心算法，内容对我来说很困难，不易做出。
在此看到了编程的功底很差，基本功不扎实。
在这次设计中，也遇到了很多问题，主要是对算法中的变量不能明确其意义，从而导致了在调试过程中出现了很多低级错误。
只有对算法理解透彻才能够快速、正确的实现算法的要求，达到满意的效果。
附：程序模块的源代码
#include<stdio.h>
int F[8];
struct
{ int data;
int tag;
}set[8];
void main()
{ int k,i,j,r,n=8,m;
int J[8]={0};
int find(int t);
int min(int a,int b);
void uin(int,int);
int p[8]={35,30,25,20,15,10,5,1},d[8]={4,2,4,5,6,4,5,7};
for(i=0;i<9;i++)
{ F[i]=i;
set[i].data=i;
set[i].tag=-1;
}
for(j=0,i=1;i<=n;i++)
{ k=min(n,d[i-1]);
r=find(k);
if(F[r]!=0){J[j++]=i;m=find(F[r]-1);uin(m,r);F[r]=F[m];} }
for(i=0;i<j;i++)
printf("%d,",J[i]);
getch();
}
int find(int t)
{ int q;
q=t;
if(F[q]==q)
return(q);
else
{
find(q-1);
}
}
int min(int a,int b)
{ int t;
t=a<b?a:b;
return t;
}
void uin(int a,int b)
{ int i;
for(i=a;i<=b;i++)
{ set[i].tag=b-i-1;
}
}。