贪心算法求解多机调度问题
贪心法 多机调度问题
//多机调度问题/*贪心法求解多级调度问题的贪心策略师最长处理时间的作业优先，即把处理时间最长的作业分配给最先空闲的机器，这样就可以保证处理时间长的作业优先处理，从而在整体上获得尽可能短的时间。
按照最长处理时间作业优先的贪心测落，当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);}。
算法之多机调度问题
}
for(i=m+1;i<=n;i++)
{
for(int k=1;k<m;k++)
{
int o=d[k];
if (o>d[k+1])
{
o=d[k+1];
j=k+1;
}
}
s[j]|=(1<<(p[i]-1));
d[j]=d[j]+t[i];
}
}
void Output(int *p,int n,int *s,int *d,int m) //阅读并理解这个函数
Dsc_Order_By_t(t,p,n); //对作业根据运行时间t进行降序排列
Processing(p,t,n,s,d,m); //用最长运行时间优先算法处理作业
Output(p,n,s,d,m); //输出结果
_getch();
return 0;
}
运行结果图：
t[]={0,2,14,4,16,6,5,3}, //对应作业时间，t[0]不用
s[]={0,0,0,0}, //机器处理的作业集合，如：s[1]存放机器处理过的作业号，s[0]不用
d[]={0,0,0,0}; //机器处理作业的总时间，如：d[2]存放机器处理过的作业的总时间，d[0]不用
int n=sizeof(p)/sizeof(int)-1,m=sizeof(s)/sizeof(int)-1; //n--作业总数，m--机器台数
算法之多机调度问题
用贪心法解决多机调度问题
（1）问题的描述
设有n个独立的作业{1, 2,…, n}，由m台相同的机器{M1, M2,…, Mm}进行加工处理，作业i所需的处理时间为ti（1≤i≤n），每个作业均可在任何一台机器上加工处理，但不可间断、拆分。多机调度问题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
贪心算法---例题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; }
贪心算法应用
for( i=0;i<n;i++)
cout<<setw(4)<<job[i].ID;
}
void solve(Header *head,Job*job,int n,int m)
{
int k;
for(int i=0;i<m&&i<n;i++)
{
JobNode *jobnode=new JobNode;
QuickSort(job,i,right);
}
void display(Header *M,int m)
{
JobNode *p;
for(int i=0;i<m;i++)
{
cout<<"\n第"<<i<<"台机器上处理的工作序号：";
if(M[i].next==0)
continue;
p=M[i].next;
(提示：1、把作业按加工所用的时间从大到小排序，2、如果作业数目比机器的数目少或相等，则直接把作业分配下去，3、如果作业数目比机器的数目多，则每台机器上先分配一个作业，如下的作业分配时，是选那个表头上s最小的链表加入新作业。)
# include <iostream>
# include <iomanip>
head[k].s+=jobnode->time;
while(p->next!=0)
p=p->nຫໍສະໝຸດ xt;p->next=jobnode;
航空行业的航空航班调度探讨航空航班调度的算法和优化方法
航空行业的航空航班调度探讨航空航班调度的算法和优化方法航空行业的航空航班调度：探讨航班调度的算法和优化方法航空行业作为现代交通运输的一个重要组成部分，航空航班的调度对于保证航空安全、提高运输效率以及满足乘客需求至关重要。
本文将探讨航空航班调度的算法和优化方法，以期增强航空公司和航空管理部门的决策能力，优化航班调度方案。
一、航空航班调度算法航空航班调度算法是基于航班信息和约束条件的数学模型，旨在合理安排航班起飞和降落的时间、地点以及航班间隔等参数，以确保航线运行顺畅。
以下是常见的航空航班调度算法：1. 贪心算法贪心算法是一种简单且高效的算法，根据当前情况做出最优决策。
在航班调度中，贪心算法可以根据航班的到达时间、起飞时间和停留时间等因素，依次安排航班的起飞和降落。
2. 遗传算法遗传算法是一种基于进化原理的搜索算法，通过模拟自然选择、交叉和变异等操作，优化问题的解。
在航班调度中，遗传算法可以通过迭代选择、交叉和变异等操作，寻找最优的航班调度方案。
3. 线性规划算法线性规划算法是一种数学优化方法，通过建立线性模型，并在约束条件下求解最优解。
在航班调度中，线性规划算法可以通过建立航班起降时间的线性模型，并优化模型中的目标函数，求解最优的航班调度方案。
二、航空航班调度优化方法除了算法之外，航空航班调度还可以采用一些优化方法，进一步提高航班调度的效率和质量。
1. 机器学习方法机器学习方法可以通过对航班历史数据的分析和建模，预测航班延误和需求变化趋势，从而优化航班调度方案。
例如，可以利用机器学习算法预测航班延误概率，并在调度中加入相应的缓冲时间，以减少延误风险。
2. 多目标优化方法航空航班调度通常涉及多个目标，如最大化航班利润、最小化延误时间等。
多目标优化方法可以通过建立多目标规划模型，并使用相关算法，找到满足多个目标的航班调度方案。
3. 协同决策方法航空航班调度涉及到多个利益相关方，如航空公司、机场、空管部门等。
多机调度问题贪心算法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。
多机调度问题
M1：2,6,3 M2：5,4 M3：14,16
设7个独立作业{1,2,3,4,5,6,7}由3台机器 M1，M2和M3加工处理。各作业所需的 处理时间分别为{2,14,4,16,6,5,3}。 将作业按从小到大依次分配给空闲的机器：
1 2 0 7 3 2 1 0 4 12 3 4 7 6 4 5 5 6 2 14 6 16 23
设7个独立作业{1,2,3,4,5,6,7}由3台机器 M1，M2和M3加工处理。各作业所需的 处理时间分别为{2,14,4,16,6,5,3}。 将作业按次序平均分配给每台机器：
机器 M1 M2 M3 作业 1,2,3 4,5 6,7 时间 2+14+4=20 16+6=22 5+3=8
优点：比较简单，容易想到 缺点：没有考虑时间代价，机器所运行的作业完 全由作业的次序决定，当运行时间比较大的作业 集中在一起时，会把它们分配给同一个机器，这 样所用的时间比较长，效率比较低
分n<=m( 作业数小于机器数)，n>m(作业数大于 机器数)求解。 当n<=m时，将n个作业分配给m台机器中的前n 台就可以了。 当 n>m 时，需要选择算法来确定最优顺序将作 业分配给空闲的处理机，使得处理时间最短。
三种解决方案： 1、将作业按次序平均分配给每台机器； 2、把作业按处理时间从小到大排序，然 后依次分配给空闲的机器； 3、把作业按处理时间从大到小排序，然 后依次分配给空闲的机器（Greedy算法）
设7个独立作业{1,2,3,4,5,6,7}由3台机器 M1，M2和M3加工处理。各作业所需 的处理时间分别为{2,14,4,16,6,5,3}。
4 16 2 14 5 6 6 5 3 4 7 3 1 2
云计算中融入贪心策略的调度算法研究
云计算中融入贪心策略的调度算法研究云计算是一种新兴的计算模式，已经成为当今计算领域的热门话题。
云计算具有高效、灵活、安全、可靠等优点，深受企业和个人用户的青睐，已成为大数据、人工智能等领域的核心技术。
然而，在云计算应用中，调度算法是一个非常关键的问题。
如何优化云计算资源的利用效率，提高云计算平台的性能，是云计算研究的重要课题之一。
云计算中的融入贪心策略的调度算法，是近年来研究的热点之一。
贪心算法是一种基于贪心思想的算法，它总是做出当前看来最优的选择。
云计算中的调度问题本质上是资源分配问题，需要合理的分配计算、存储、网络等资源，以最大化利润或最小化成本。
基于贪心思想的调度算法，可以有效地解决云计算中的任务分配和资源分配问题，提高资源利用率和平台性能。
在云计算中，任务分配和资源分配是两个重要的问题。
任务分配就是将用户提交的任务分配到云计算平台中的多个计算节点中执行。
在这个过程中，需要考虑到不同任务的数据量、执行时间、优先级等因素，以及计算资源的状态、类型、数量等。
在分配任务时，采用贪心算法可以使分配过程更加高效简单。
例如，可以采用最短作业优先（SJF）算法，对任务进行排序，并按照顺序分配资源。
这样可以有效地减少系统开销和能量消耗，提高计算平台的效率。
资源分配是指将计算、存储、网络等资源合理地分配到不同的计算节点中，以满足用户需求，提高平台性能。
在资源分配过程中，需要考虑到不同任务的资源要求、任务的优先级以及节点间的带宽、延迟等因素。
采用贪心算法可以使资源分配更加高效和灵活。
例如，可以采用最大利用率优先（MUP）算法，对节点进行排序，并按照顺序分配资源。
这样可以最大化利用计算资源，提高系统的整体性能。
需要注意的是，贪心算法具有局限性。
在实际应用中，贪心算法的效果很大程度上取决于问题的特点和算法的实现。
对于某些问题而言，贪心算法可能不是最优解，甚至可能会导致局部最优解而无法到达全局最优解。
因此，在使用贪心算法进行任务分配和资源分配时，需要结合实际情况，适当地调整算法参数和策略，使得算法更加可靠和稳健。
【分析】算法分析与设计作业参考答案
【关键字】分析《算法分析与设计》作业参考答案作业一一、名词解释：1.递归算法：直接或间接地调用自身的算法称为递归算法。
2.程序：程序是算法用某种程序设计语言的具体实现。
2、简答题：1.算法需要满足哪些性质？简述之。
算法是若干指令的有穷序列，满足性质：1）输入：有零个或多个外部量作为算法的输入。
2）输出：算法产生至少一个量作为输出。
3）确定性：组成算法的每条指令清晰、无歧义。
4）有限性：算法中每条指令的执行次数有限，执行每条指令的时间也有限。
2.简要分析分治法能解决的问题具有的特征。
分析分治法能解决的问题主要具有如下特征：1）该问题的规模缩小到一定的程度就可以容易地解决；2）该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质；3）利用该问题分解出的子问题的解可以合并为该问题的解；4）该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。
3.简要分析在递归算法中消除递归调用，将递归算法转化为非递归算法的方法。
将递归算法转化为非递归算法的方法主要有：1）采用一个用户定义的栈来模拟系统的递归调用工作栈。
该方法通用性强，但本质上还是递归，只不过人工做了本来由编译器做的事情，优化效果不明显。
2）用递推来实现递归函数。
3）通过Cooper变换、反演变换能将一些递归转化为尾递归，从而迭代求出结果。
后两种方法在时空复杂度上均有较大改善，但其适用范围有限。
三、算法编写及算法应用分析题：1.冒泡排序算法的基本运算如下：for i ←1 to n-1 dofor j ←1 to n-i doif a[j]<a[j+1] then交换a[j]、a[j+1]；分析该算法的时间复杂性。
解答：排序算法的基本运算步为元素比较，冒泡排序算法的时间复杂性就是求比较次数与n的关系。
1）设比较一次花时间1；2）内循环次数为：n-i次,（i=1,…n），花时间为：3）外循环次数为：n-1，花时间为：2.设计一个分治算法计算一棵二叉树的高度。
贪心算法及其应用
贪心算法及其应用近年来，随着科技的发展和数据的爆炸式增长，优化问题成为了研究的热点。
在高效解决各种优化问题中，贪心算法发挥了重要作用。
本文将介绍贪心算法的定义、特点、优缺点及其常见应用。
一、什么是贪心算法贪心算法是一种常见的算法方法，通过贪心策略来求解问题的最优解。
其思想是在每一个阶段上，选择当前最优解的策略，最终得到的就是问题的最优解。
二、贪心算法的特点贪心算法具有以下特点：1、局部最优解一定是全局最优解的一个组成部分；2、求解过程中不需要回溯；3、贪心算法具有高效性，时间复杂度低。
三、贪心算法的优缺点1、优点贪心算法具有简单、高效等优点。
对于那些没有明确要求最优解的问题，贪心算法是一个不错的选择。
2、缺点贪心算法的局限性在于，有些问题不能用贪心策略求得最优解。
因为每一步选择的最优解并不一定能导致全局最优解。
此外，贪心算法需要注意到问题的结构性质，否则可能做出错误决策。
四、贪心算法的应用1、背包问题背包问题是一个最经典的贪心算法应用场景。
在这个问题中，我们需要将一组物品放到一个容器中。
每个物品有一个权值和一个体积。
容器有一个最大承载体积，求容器可以承载的最大权值。
使用贪心算法在背包问题中是具有局限性的。
但是，在有些情况下，贪心策略是可行的。
例如在只考虑单个维度时，贪心算法以效率极高的速度求得其最优解。
2、最小生成树最小生成树问题是一个常见的求解问题。
其问题的目标是在一张图中找到一棵生成树，该树的所有边权之和最小。
在这个问题中，我们采用贪心策略选择当前最优边并添加到生成树中，以此来求得最优解。
3、哈夫曼编码哈夫曼编码是一种广泛应用的数据压缩算法。
其通过根据字符出现频率选择具有最小权值的二叉树节点，最终构建出哈夫曼树，以此来表示字符的编码信息。
使用哈夫曼编码可以实现对数据的高效压缩和解压缩。
4、调度问题在调度问题中，我们需要找到一种方案，让若干任务在满足约束条件的前提下，以最短的时间完成。
例如，在机器调度问题中，我们需要为不同机器安排任务以最小化整体完成时间。
贪心算法求解多机调度问题
多机调度问题一、 问题描述设有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）。
在上述的问题中，使用贪心算法得到的结果恰好就是问题整体的最优解。
对于一个具体的问题，怎么知道是否可用贪心算法来解此问题，以及能否得到问题的一个最优解呢？这个问题很难给予肯定的回答。
但是，许多可以用贪心算法求解的问题中一般具有两个重要的性质：贪心选择性质和最优子结构性质。
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择即贪心选择来达到，这是贪心算法可行的第一个基本要素。
对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所做的贪心选择最终将会得到问题的一个整体最优解。
首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始。
算法分析期末考试集答案（套）
算法分析期末考试集答案（套）《算法分析与设计》⼀、解答题 1. 机器调度问题。
问题描述：现在有n 件任务和⽆限多台的机器，任务可以在机器上得到处理。
每件任务的开始时间为s i ，完成时间为f i ，s i问题实例：若任务占⽤的时间范围是{[1，4]，[2，5]，[4，5]，[2，6]，[4，7]}，则按时完成所有任务最少需要⼏台机器？（提⽰：使⽤贪⼼算法）画出⼯作在对应的机器上的分配情况。
2. 已知⾮齐次递归⽅程：f (n)bf (n 1)g(n)f (0)c =-+??=? ，其中，b 、c 是常数，g(n)是n 的某⼀个函数。
则f(n)的⾮递归表达式为：nnn i i 1f (n)cb b g(i)-==+∑。
现有Hanoi 塔问题的递归⽅程为：h(n)2h(n 1)1h(1)1=-+??=? ，求h(n)的⾮递归表达式。
解：利⽤给出的关系式，此时有：b=2, c=1, g(n)=1, 从n 递推到1，有：n 1n 1n 1i i 1n 1n 22n h(n)cbb g(i)22 (22121)----=--=+=+++++=-∑3. 单源最短路径的求解。
问题的描述：给定带权有向图（如下图所⽰）G =(V,E)，其中每条边的权是⾮负实数。
另外，还给定V 中的⼀个顶点，称为源。
现在要计算从源到所有其它各顶点的最短路长度。
这⾥路的长度是指路上各边权之和。
这个问题通常称为单源最短路径问题。
解法：现采⽤Dijkstra 算法计算从源顶点1到其它顶点间最短路径。
请将此过程填⼊下表中。
4. 请写出⽤回溯法解装载问题的函数。
装载问题：有⼀批共n 个集装箱要装上2艘载重量分别为c1和c2的轮船，其中集装箱i 的重量为wi ，且121nii w c c=≤+∑。
装载问题要求确定是否有⼀个合理的装载⽅案可将这n 个集装箱装上这2艘轮船。
如果有，找出⼀种装载⽅案。
解：void backtrack (int i){// 搜索第i 层结点if (i > n) // 到达叶结点更新最优解bestx,bestw;return; r -= w[i];if (cw + w[i] <= c) {// 搜索左⼦树43 2 1 100 30 maxint10 - {1} 初始 dist[5] dist[4] dist[3] dist[2] u S 迭代x[i] = 1;cw += w[i];backtrack(i + 1);cw -= w[i]; }if (cw + r > bestw) {x[i] = 0; // 搜索右⼦树backtrack(i + 1); }r += w[i];}5. ⽤分⽀限界法解装载问题时，对算法进⾏了⼀些改进，下⾯的程序段给出了改进部分；试说明斜线部分完成什么功能，以及这样做的原因，即采⽤这样的⽅式，算法在执⾏上有什么不同。
多机调度问题贪心算法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)。
贪心算法求解多机调度问题
设有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 <iostream>
using namespace std;
void Greedy(int t[],int n,int m);
int main() {
int n=7,m=3,t[]={2,14,4,16,6,5,3};//待分配的工作
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<n;i++)
{ int max=0,min=10000;
flagn=0;
flagm=0;
for(int j=0;j<n;j++)//选择时间最多的工作
{ if(max<t[j]) { max=t[j]; flagn=j; } }
for(j=0;j<m;j++)//选择工作量最小的机器
{
if(M[flagm]>M[j])
{flagm=j;}
}
M[flagm]=M[flagm]+t[flagn]; t[flagn]=0; //被选择过的机器时间调为0 cout<<flagn<<"work "<<flagm<<"machine"<<endl; } }。