贪心算法-多机调度问题C++

1.问题
要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。作业不能拆分成更小的子作业。

2.算法解析
此算法的贪心策略主要在于Sort排序算法，按照作业时间从大到小进行排序。然后再考虑机器数量：（1）如果机器数量大于等于作业数，那么直接同时运行所有作业，其运行至少所需的时间就为所有作业中最大时间的那个作业的时间。（2）如果机器数小于作业数，则作业时间最少或者空闲的机器优先安排作业。

3.代码

①所需数据结构

typedef struct Job{
//作业的信息，用于定义作业数组a[]
	int ID;
	int time;
}Job;

typedef struct JobNode{
//作业节点信息，记录每个机器运行的作业
	int ID;
	int time;
	JobNode *next;
}JobNode, *pJobNode;

typedef struct Header{
//机器头节点，其中s为该机器需要运行作业的总时间，用于定义作业数组M[]
	int s;
	pJobNode next;
}Header, pHeader;

②排序函数Sort()：

void Sort(Job *a, int n){
//采用冒泡排序策略
	Job temp;
	for(int i=0; i<n; i++)
		for(int j=i+1; j<n; j++)
			if(a[i].time < a[j].time){
				temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
}

③选择最小值函数SelectMin()：

int SelectMin(Header *M, int m){
//读取头节点的s值，得出运行时间最小的机器下标并返回
	int k = 0;
	for(int i=1; i<m; i++)
		if(M[i].s < M[k].s)
			k = i;
	return k;
}

④选择最大值函数SelectMax()：

int SelectMax(Header *M, int m){
//用于最后得出所有作业完成至少需要多少时间的函数
//也是对头节点的s进行比较
	int k = 0;
	for(int i=1; i<m; i++)
		if(M[i].s > M[k].s)
			k = i;
	return k;
}

⑤作业调度函数Dispatch()：

int Dispatch(Job *a, Header *M, int n, int m){
	int min, max;
	JobNode *p, *q;     				//中间变量
	for(int i=0; i<n; i++){
		M[i].s = 0; M[i].next = NULL;   //将机器的总时间和作业指针初始化
	} 
	Sort(a, n);          //将a[]作业数组从小到大进行排序
	if(n <= m)
		return a[0].time;  //作业数小于机器数的情况，直接取排好序的作业数组第一个元素
	for(int j=0; j<n; j++){
		q = (pJobNode)malloc(sizeof(JobNode));   //给中间变量分配空间
		min = SelectMin(M, m);    //得出作业时间总和最小的机器的下标
		M[min].s += a[j].time;   
		q->ID = a[j].ID;		//将a数组中的元素变成作业节点数据
		q->time = a[j].time;
		q->next = NULL;			//尾指针置空
		if(!M[min].next)		//M未进行节点插入的情况，加入作业节点到头节点之后
			M[min].next = q;
		else{					//M已有作业节点的情况，加入作业节点到尾部
			p = M[min].next;
			while(p->next)
				p = p->next;
			p->next = q;
		}
	}
	Print(M, m);				//输出每台机器的运行作业的ID
	max = SelectMax(M, m);		//得出最大的s的机器的下标
	return M[max].s;			//返回至少需要的时间
}

⑥全部代码

#include<iostream>
#include<cstdlib>
using namespace std;
typedef struct Job{
	int ID;
	int time;
}Job;
typedef struct JobNode{
	int ID;
	int time;
	JobNode *next;
}JobNode, *pJobNode;
typedef struct Header{
	int s;
	pJobNode next;
}Header, pHeader;
int SelectMin(Header *M, int m){
	int k = 0;
	for(int i=1; i<m; i++)
		if(M[i].s < M[k].s)
			k = i;
	return k;
}
int SelectMax(Header *M, int m){
	int k = 0;
	for(int i=1; i<m; i++)
		if(M[i].s > M[k].s)
			k = i;
	return k;
}
void Sort(Job *a, int n){
	Job temp;
	for(int i=0; i<n; i++)
		for(int j=i+1; j<n; j++)
			if(a[i].time < a[j].time){
				temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
}
void Print(Header *M, int m){
	JobNode *p;
	for(int i=0; i<m; i++){
		cout<<"第"<<i+1<<"台机器运行的作业ID为："; 
		p = M[i].next;
		while(p){
			cout<<p->ID<<" ";
			p = p->next;
		}
		cout<<endl;
	}
}
int Dispatch(Job *a, Header *M, int n, int m){
	int min, max;
	JobNode *p, *q;
	for(int i=0; i<n; i++){
		M[i].s = 0; M[i].next = NULL; 
	} 
	Sort(a, n);
	if(n <= m)
		return a[0].time;
	for(int j=0; j<n; j++){
		q = (pJobNode)malloc(sizeof(JobNode));
		min = SelectMin(M, m);
		M[min].s += a[j].time;
		q->ID = a[j].ID;
		q->time = a[j].time;
		q->next = NULL;
		if(!M[min].next)
			M[min].next = q;
		else{
			p = M[min].next;
			while(p->next)
				p = p->next;
			p->next = q;
		}
	}
	Print(M, m);
	max = SelectMax(M, m);
	return M[max].s;
}
int main(){
	int n, m, maxtime;
	Job a[10];
	Header M[10];
	cout<<"输入作业数和机器数："; 
	cin>>n>>m;
	cout<<"输入作业ID和时间："<<endl; 
	for(int i=0; i<n; i++){
		cin>>a[i].ID>>a[i].time;
	}
	maxtime = Dispatch(a, M, n, m);
	cout<<"作业全部运行完成所需最短时间为："<<maxtime<<endl;
}
/*
7 3
1 2
2 14
3 4
4 16
5 6
6 5
7 3
*/

4.运行结果