算法：批处理作业调度（回溯）

1、问题描述

每一个作业Ji都有两项任务分别在2台机器上完成。每个作业必须先有机器1处理，然后再由机器2处理。作业Ji需要机器j的处理时间为tji。对于一个确定的作业调度，设Fji是作业i在机器j上完成处理时间。则所有作业在机器2上完成处理时间和f=F2i，称为该作业调度的完成时间和

２、简单描述

对于给定的n个作业，指定最佳作业调度方案，使其完成时间和达到最小。

区别于流水线调度问题：批处理作业调度旨在求出使其完成时间和达到最小的最佳调度序列；

流水线调度问题旨在求出使其最后一个作业的完成时间最小的最佳调度序列；

３、题意理解

考虑n=3 这个3个作业的6种可能的调度方案是（1,2,3）（1，3,2）（2,1,3）（2,3,1）（3,1,2）（3,2,1）对应的完成时间和分别是19,18,20,21,19,19

４、举例说明

算法设计批处理作业调度问题要从n个作业的所有排列中找出有最小完成时间和的作业调度，所以批处理作业调度问题的解空间是一颗排列树。

　　

　　按照回溯法搜索排列树的算法框架，设开始时x=[1,2, … , n]是所给的n个作业，则相应的排列树由x[1:n]的所有排列（所有的调度序列）构成。

二维数组M是输入作业的处理时间，bestf记录当前最小完成时间和，bestx记录相应的当前最佳作业调度。

在递归函数Backtrack中，

当i>n时，算法搜索至叶子结点，得到一个新的作业调度方案。此时算法适时更新当前最优值和相应的当前最佳调度。

当i<n时，当前扩展结点位于排列树的第（i-1）层，此时算法选择下一个要安排的作业，以深度优先方式递归的对相应的子树进行搜索，对不满足上界约束的结点，则剪去相应的子树。
４、算法分析

【前期准备】

1、区分作业i和当前第i个正在执行的作业
　　　给x赋初值，即其中一种排列，如x=[1,3,2]；M[x[j]][i]代表当前作业调度x排列中的第j个作业在第i台机器上的处理时间；如M[x[2]][1]就意味着作业3在机器1上的处理时间。
2、bestf的初值
　　　此问题是得到最佳作业调度方案以便使其完成时间和达到最小，所以当前最优值bestf应该初始化赋值为较大的一个值。
3、f1、f2的定义与计算
　　　假定当前作业调度排列为：x=[1,2,3]；f1[i]即第i个作业在机器1上的处理时间，f2[j]即第j个作业在机器2上的处理时间；则：
　　　　　　f1[1]=M[1][1] , f2[1]=f1[1]+M[1][2]
　　　　　　f1[2]=f1[1]+M[2][1] , f2[2]=MAX(f2[1],f1[2])+M[2][2]　//f2[2]不光要等作业2自己在机器1上的处理时间，还要等作业1在机器2上的处理时间，选其大者。
　　　　　　f1[3]=f1[2]+M[3][1] , f2[3]=MAX(f2[2],f1[3])+M[3][2]
　　1只有当前值有用，可以覆盖赋值，所以定义为int型变量即可，减少空间消耗；f2需要记录每个作业的处理时间，所以定义为int *型，以便计算得完成时间和。
4、f2[0]的初值
　　　f2[i]的计算都是基于上一个作业f2[i-1]进行的，所以要记得给f2[0]赋值为0。
源代码：

#include<bits/stdc++.h>
using namespace std;

int M[4][3]={0,0,0,0,2,1,0,3,1,0,2,3};//作业所需的处理时间

class Flowshop
{
  friend Flow(int **,int,int[]);
  public:
    void Backtrack(int i);
      *x,//当前作业调度
      *bestx,//当前最优作业调度
        *f2,//机器2完成处理时间
      f1,//机器1完成处理时间
      f,//完成时间和
      bestf,//当前最优值
      n;//作业数 
};

void Flowshop::Backtrack(int i)
{
  if(i>n)
  {
    for(int j=1;j<=n;j++)
    {
      bestx[j]=x[j];
    }
    bestf=f;
  }
  else
  {
    for(int j=i;j<=n;j++)
    {
      f1+=M[x[j]][1];
      f2[i]=((f2[i-1]>f1)?f2[i-1]:f1)+M[x[j]][2];
      f+=f2[i];
      if(f<bestf)
      {
        swap(x[i],x[j]);
        Backtrack(i+1);
        swap(x[j],x[i]);
      }
      f1-=M[x[j]][1];
      f-=f2[i];
    }
  }
}

int Flow(int n,int bestx[])
{
  int ub = 32767;
  Flowshop X;
  X.x =  new int[n+1];
  X.f2 = new int[n+1];
  X.n = n;
  X.bestx = bestx;
  X.bestf = ub;
  X.f1 = 0;
  X.f  = 0;
  for(int i=0;i<=n;i++)
  {
    X.f2[i]  = 0;
    X.x[i] = i;
  }
  X.Backtrack(1);
  for(int i=1;i<=n;i++)
  {
    cout<<X.bestx[i]<<endl;
  }
  delete [] X.x;
  delete [] X.f2;
  return X.bestf;  
}

int main()
{   
  
  int n=3;
  int bestx[4];
  int result = Flow(n,bestx);
  cout<<result;
  return 0;
}

运行效果：