回溯法-5.3批处理作业调度

问题描述：给定n个作业的集合{J1,J2,…,Jn}。每个作业必须先由机器1处理，然后由机器2处理。作业Ji需要机器j的处理时间为tji。对于一个确定的作业调度，设Fji是作业i在机器j上完成处理的时间。所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。
批处理作业调度问题要求对于给定的n个作业，制定最佳作业调度方案，使其完成时间和达到最小

分析：这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。易见，最佳调度方案是1,3,2，其完成时间和为18。
以3，1，2顺序为例：

算法实现步骤

1.if(当前层大于总数) 遍历到排序树的叶节点
2.else 遍历到排序树的第k层节点
—①先向下一层子节点探索
—-if(若当前完成时间和小于当前最优值) 则递归到下一层节点
—②回溯到父节点

public class test5_3 {
    static int n = 3,                        //作业数                               (需初始化)
               f = 0,                        //完成时间和
               f1 = 0,                       //机器1完成处理时间
               bestf = Integer.MAX_VALUE;    //当前最优值                        (需初始化最大值)
    static int[][] m = {{0,0,0}              //各作业所需的处理时间       (需初始化)
                       ,{0,2,1}
                       ,{0,3,1}
                       ,{0,2,3}};
    static int[] x = {0,1,2,3};              //当前作业调度                     (需初始化)
    static int[] bestx = new int[n+1];       //当前最优作业调度
    static int[] f2 = new int[n+1];          //机器2完成处理时间
    /**
     * 回溯法
     * @param k 表示遍历的排序树的层数,初始k=1,表示从第一层根节点开始
     */
    private static void backtrack(int k){
        //1.遍历到排序树的叶节点
        if(k>n){
            for(int i=1;i<=n;i++)
                bestx[i] = x[i];
            bestf = f;
        }else
        //2.遍历到排序树的第k层节点    k∈[1:n]
            for(int i=k;i<=n;i++){   //排列树下此for循环抽象成广度优先搜索,即从k节点下的(n-k)个子分支依次遍历
                //*****2.1先向下一层子节点探索****(值的探索)******************
                f1 += m[x[i]][1];
                f2[k] = ((f2[k-1]>f1)? f2[k-1]:f1) + m[x[i]][2];
                f += f2[k];
                //*****2.1先向下一层子节点探索*****(值的探索)*****************
                //*****2.2若当前完成时间和小于当前最优值,则递归到下一层节点********
                if(f<bestf){ 
                    swap(x,k,i);//类别全排列算法(节点的真正探索)
                    backtrack(k+1);  //抽象成深度优先搜索,即递归到下一层节点
                    swap(x,k,i);//类别全排列算法(节点的真正回溯)
                }
                //*****2.2若当前完成时间和小于当前最优值,则递归到下一层节点********
                //*****2.3回溯到父节点***********(值的回溯)*****************
                f1 -= m[x[i]][1];
                f -= f2[k];
                //*****2.3回溯到父节点***********(值的回溯)****************
            }
    }
    private static void swap(int[] x,int i,int j){
        int temp;
        temp = x[i];
        x[i] = x[j];
        x[j] = temp;
    }
    public static void main(String[] args) {
        backtrack(1);
        System.out.println("最优调度下完成时间和为："+bestf);
        System.out.print("最优作业调度顺序如下：");
        for(int i=1;i<=n;i++)
            System.out.print(bestx[i]+" ");
    }
}

运行结果如下：

最优调度下完成时间和为：18
最优作业调度顺序如下：1 3 2 

总结：最坏情况下，整个算法的时间复杂度为O(n!)。