流水作業調度問題算法的java實現（動態規劃法）
具體問題描述以及C/C++實現參見網址
http://blog.csdn.net/liufeng_king/article/details/8678316
/**
* 流水佈線問題（動態規劃）
* @author Lican
*
*/
public class Johnson {
public int[] a;
public int[] b;
public int[] c;
public Johnson(int[] aa,int[] bb){
this.a=aa;
this.b=bb;
this.c= new int[aa.length];
}
private static class Element implements Comparable{
int key;
int index;
boolean job;
public Element(int kk,int ii,boolean jobs){
key = kk;
index = ii;
job = jobs;
}
@Override//根據key值進行排序（升序）
public int compareTo(Object arg0) {
int keys =((Element)arg0).key;
if(key<keys) return -1;
if(key==keys) return 0;
return 1;
}
}
public int flowShop(int[] a,int[] b,int[] c){
int n = a.length;
Element[] d = new Element[n];
for(int i=0;i<n;i++){
int key=a[i]>b[i]? b[i]:a[i];//按Johnson法則分別取對應的b[i]或a[i]值作爲關鍵字
boolean job = a[i]<=b[i];//給符合條件a[i]<b[i]的放入到N1子集標記爲true
d[i] = new Element(key,i,job);
}
java.util.Arrays.sort(d);//對數組d按關鍵字升序進行排序
int j=0;
int k=n-1;
for(int i=0;i<n;i++){
if(d[i].job)
c[j++]=d[i].index;//將排過序的數組d，取其中作業序號屬於N1的從前面進入（d[i].index保存的作業序號0，1，2，等等）
else
c[k--]=d[i].index;//屬於N2的從後面進入，從而實現N1的非減序排序，N2的非增序排序
}
j=a[c[0]];
k=j+b[c[0]];//對於第一個任務，j爲M1執行第一個任務的時間，k爲M1+M2執行第一個任務的時間，即第一個任務在M1，M2上都執行完的時間
for(int i=1;i<n;i++){
j+=a[c[i]];//M1在執行c[i]作業的同時，M2在執行c[i-1]號作業，最短執行時間取決於M1與M2誰後執行完
k=j<k?k+b[c[i]]:j+b[c[i]];//計算最優加工時間
}
System.out.println("作業調度的順序爲(編號從0開始)：");
for(int i=0;i<c.length;i++){
System.out.print(c[i]+" ");
}
System.out.println();
return k;
}
public static void main(String[] args) {
int[] a = {2,4,3,6,1};
int[] b = {5,2,3,1,7};
Johnson j = new Johnson(a,b);
int k = j.flowShop(j.a, j.b, j.c);
System.out.println("完成作業的最短時間爲:"+k);
}
}算法實現的結果如下：
對於算法的java實現代碼，自己的總結：
1)首先將a，b從（i=1--n），將a[i]，b[i]中，小的那個放到數組d的key裏；並按key將n個Element進行排序
2)d[i].job作爲標誌（true，即a[i]<=b[i0]）,屬於N1，用c[i]的前幾個保存index，即作業標號（0，1,2,3.。。。。）
（false，即a[i]>b[i0]）,屬於N2，用c[i]的後幾個保存index，即作業標號（0，1,2,3.。。。。）
3)最後，循環按c[i]的作業標號，計算所需時間（即a[c[i]]）