贪心法求解流水作业调度问题

问题描述

有n个作业（编号为1～n）要在由两台机器M1和M2组成的流水线上完成加工。每个作业加工的顺序都是先在M1上加工，然后在M2上加工。M1和M2加工作业i所需的时间分别为ai和bi（1≤i≤n）。
流水作业调度问题要求确定这n个作业的最优加工顺序，使得从第一个作业在机器M1上开始加工，到最后一个作业在机器M2上加工完成所需的时间最少。可以假定任何作业一旦开始加工，就不允许被中断，直到该作业被完成，即非优先调度。

问题求解

采用归纳思路。当只有一个作业（a1，b1），显然最少时间Tmin=a1+b1。
当有两个作业（a1，b1）和（a2，b2）时，若（a1，b1）在前（a2，b2）在后执行：

Tmin=a1+b1+a2+b2-min(a2，b1)。
若(a2，b2)在前（a1，b1）在后执行，可以求出最少时间
Tmin=a2+b2+a1+b1-min(b2，a1)
将两种执行顺序合并起来有：Tmin=a1+b1+a2+b2-max(min(a2，b1)，min(a1，b2))
由此可以得到一个贪心的性质：
对于(a1，b1)和(a2，b2)中的元素
若min(a1，b2)≤min(a2，b1)，则(a1，b1)放在(a2，b2)前面；
反之，若min(a2，b1)≥min(a1，b2) (a2，b2)放在(a1，b1)前面。
让(a,b)中a比较小的尽可能先执行，(a,b)中b比较小的尽可能后执行！

Johnson贪心算法，其步骤如下：
（1）把所有作业按M1、M2的时间分为两组，a[i]≤b[i]对应第1组N1，a[i]>b[i]对应第0组N2。
（2）将N1的作业按a[i]递增排序，N2的作业按b[i]递减排序。
（3）按顺序先执行N1的作业，再执行N2的作业，得到的就是耗时最少的最优调度方案。

求在最优调度下总时间，用f1累计M1上的执行时间（初始时f1=0）；f2累计M2上的执行时间（初始时f2=0），最终f2即为最优调度下的消耗总时间。
对于最优调度方案best，用i扫描best的元素，f1和f2的计算如下：
f1=f1+a[best[i]]
f2=max{f1，f2}+b[best[i]]

代码

int n = 4;
int a[MAXN] = { 5,12,4,8 };
int b[MAXN] = { 6,2,14,7 };

struct NodeType
{
	int no;//作业序号
	bool group;//1代表第一组N1，0代表第二组N2
	int time;//a，b的最小时间
	bool operator<(const NodeType &s)const
	{
		return time < s.time;
	}
};

int best[MAXN];

int solve()
{
	NodeType c[MAXN];
	for (int i = 0; i < n; i++)
	{
		c[i].no = i;
		c[i].group = (a[i] <= b[i]);
		c[i].time = a[i] <= b[i] ? a[i] : b[i];
	}
	sort(c, c + n);//按照时间递增排序
	int j = 0, k = n - 1;
	for (int i = 0; i < n; i++)
	{
		if (c[i].group == 1)//第一组的放在前面
			best[j++] = c[i].no;
		else//第二组的放在后面
			best[k--] = c[i].no;
	}
	int f1 = 0;
	int f2 = 0;
	for (int i = 0; i < n; i++)
	{
		f1 += a[best[i]];
		f2 = max(f2, f1) + b[best[i]];
	}
	return f2;
}

算法分析

算法的主要时间花费在排序上，所以时间复杂度为O(nlog2n)。比采用回溯法和分枝限界法求解更高效。