流水作业调度的Johnson 算法

     如果作业i和j满足，则称作业i和j满足Johnson不等式。如果作业i和j不满足Johnson不等式，则交换作业i和j的加工次序后，作业i和j满足Johnson不等式。

流水作业调度的Johnson 算法：

#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
class Jobtype
{
  public:
  int time;     // 执行时间
  int index;    // 作业序号
  bool group;   // 作业所属组，一共两个机器，1为第一组，0为第二组

  int operator <= (Jobtype a) const // 重载<=号
  {
      return (time <= a.time);
  }

};

bool compare(Jobtype a, Jobtype b)      // sort使用
{
  return a.time<b.time;                 //升序排列，如果改为return a>b，则为降序
}

// 按照Johnson法则执行流水作业调度
/*
流水作业调度问题的Johnson算法：

1. 令M={i|Mi<Ni},N={i|Mi>=Ni}

2. 将M中任务以Mi非递减排序，将N中作业依Ni非递增排序

3. M中任务接N中任务即为Johnson法则的最优调度

*/
int FlowShop(int n, int a[], int b[], int c[])
{
    Jobtype * d = new Jobtype[n];

    // 得到n个作业中，每个作业的最小加工时间

    for (int i = 0; i < n; i++)
    {
        d[i].time = a[i] > b[i] ? b[i] : a[i];       // 执行时间
        d[i].group = a[i] <= b[i];                   // 作业所属组，一共两个机器，1为第一组，0为第二组
        d[i].index = i;                              // 作业序号
    }

    sort(d, d + n, compare);    // 按d中作业时间增序排序
    int j = 0, k = n -1;
    for(int i = 0; i < n; i++)
    {
        if (d[i].group)        // 如果是第一组，则从0开始放入c[]，c[]是最优调度序列
        {
            c[j++] = d[i].index;
        }
        else
        {
            c[k--] = d[i].index;
        }
    }

    j = a[c[0]];                // 计算最优调度序列下的消耗总时间
    k = j + b[c[0]];
    for (int i = 1; i < n; i++)
    {
        j += a[c[i]];
        k = j < k ? k + b[c[i]] : j + b[c[i]];  // 求得消耗总时间的最大值
    }
    delete d;
    return k;
}

int main()
{
    //cout << "Hello world!" << endl;
    int a[] = {2, 5, 9, 12};            // 第一台机器的加工时间
    int b[] = {7, 3, 10, 13};           // 第二台机器的加工时间
    int n = sizeof(a) / sizeof(int);    // 作业数
    int* c = new int[n];                // 最优调度序列
    int Result = FlowShop(n, a, b, c);  // 最优调度时间的总数
    cout << Result << endl;
    for (int i = 0; i < n; i++)         // 输出最优调度序列
    {
        cout << c[i] << " ";
    }
    cout << endl;
    return 0;
}