問題描述

     給定n個作業的集合{J1,J2,…,Jn}。每個作業必須先由機器1處理，然後由機器2處理。作業Ji需要機器j的處理時間為tji。對於一個確定的作業排程，設Fji是作業i在機器j上完成處理的時間。所有作業在機器2上完成處理的時間和稱為該作業排程的完成時間和。

批處理作業排程問題要求對於給定的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。易見，最佳排程方案是1,3,2，其完成時間和為18。

限界函式

 批處理作業排程問題要從n個作業的所有排列中找出具有最小完成時間和的作業排程，所以如圖，批處理作業排程問題的解空間是一顆排列樹。

     在作業排程問相應的排列空間樹中，每一個節點E都對應於一個已安排的作業集。以該節點為根的子樹中所含葉節點的完成時間和可表示為：

     設|M|=r，且L是以節點E為根的子樹中的葉節點，相應的作業排程為{pk,k=1,2,……n}，其中pk是第k個安排的作業。如果從節點E到葉節點L的路上，每一個作業pk在機器1上完成處理後都能立即在機器2上開始處理，即從pr+1開始，機器1沒有空閒時間，則對於該葉節點L有：

注：(n-k+1)t1pk,因為是完成時間和，所以，後續的(n-k+1)個作業完成時間和都得算上t

如果不能做到上面這一點，則s1只會增加，從而有：。

     類似地，如果從節點E開始到節點L的路上，從作業pr+1開始，機器2沒有空閒時間，則：

     同理可知，s2是的下界。由此得到在節點E處相應子樹中葉節點完成時間和的下界是：

     注意到如果選擇Pk，使t1pk在k>=r+1時依非減序排列，S1則取得極小值。同理如果選擇Pk使t2pk依非減序排列，則S2取得極小值。 

     這可以作為優先佇列式分支限界法中的限界函式。 

     演算法描述

演算法中用最小堆表示活節點優先佇列。最小堆中元素型別是MinHeapNode。每一個MinHeapNode型別的節點包含域x,用來表示節點所相應的作業排程。s表示該作業已安排的作業時x[1:s]。f1表示當前已安排的作業在機器1上的最後完成時間；f2表示當前已安排作業在機器2上的完成時間；sf2表示當前已安排的作業在機器2上的完成時間和；bb表示當前完成時間和下界。二維陣列M表示所給的n個作業在機器1和機器2所需的處理時間。在類Flowshop中用二維陣列b儲存排好序的作業處理時間。陣列a表示陣列M和b的對應關係。演算法Sort實現對各作業在機器1和2上所需時間排序。函式Bound用於計算完成時間和下界。

     函式BBFlow中while迴圈完成對排列樹內部結點的有序擴充套件。在while迴圈體內演算法依次從活結點優先佇列中取出具有最小bb值（完成時間和下界）的結點作為當前擴充套件結點，並加以擴充套件。 演算法將當前擴充套件節點E分兩種情形處理：

　1)首先考慮E.s=n的情形，當前擴充套件結點E是排列樹中的葉結點。E.sf2是相應於該葉結點的完成時間和。當E.sf2 < bestc時更新當前最優值bestc和相應的當前最優解bestx。 

    2)當E.s<n時，演算法依次產生當前擴充套件結點E的所有兒子結點。對於當前擴充套件結點的每一個兒子結點node，計算出其相應的完成時間和的下界bb。當bb < bestc時，將該兒子結點插入到活結點優先佇列中。而當bb bestc時，可將結點node捨去。 

    演算法具體實現如下：

     1、MinHeap2.h

#include <iostream>

template<class Type>
class Graph;

template<class T> 
class MinHeap 
{ 
	template<class Type>
	friend class Graph;
	public: 
		MinHeap(int maxheapsize = 10); 
		~MinHeap(){delete []heap;} 

		int Size() const{return currentsize;} 
		T Max(){if(currentsize) return heap[1];} 

		MinHeap<T>& Insert(const T& x); 
		MinHeap<T>& DeleteMin(T &x); 

		void Initialize(T x[], int size, int ArraySize); 
		void Deactivate(); 
		void output(T a[],int n);
	private: 
		int currentsize, maxsize; 
		T *heap; 
}; 

template <class T> 
void MinHeap<T>::output(T a[],int n) 
{ 
	for(int i = 1; i <= n; i++) 
	cout << a[i] << " "; 
	cout << endl; 
} 

template <class T> 
MinHeap<T>::MinHeap(int maxheapsize) 
{ 
	maxsize = maxheapsize; 
	heap = new T[maxsize + 1]; 
	currentsize = 0; 
} 

template<class T> 
MinHeap<T>& MinHeap<T>::Insert(const T& x) 
{ 
	if(currentsize == maxsize) 
	{ 
		return *this; 
	} 
	int i = ++currentsize; 
	while(i != 1 && x < heap[i/2]) 
	{ 
		heap[i] = heap[i/2]; 
		i /= 2; 
	} 

	heap[i] = x; 
	return *this; 
} 

template<class T> 
MinHeap<T>& MinHeap<T>::DeleteMin(T& x) 
{ 
	if(currentsize == 0) 
	{ 
		cout<<"Empty heap!"<<endl; 
		return *this; 
	} 

	x = heap[1]; 

	T y = heap[currentsize--]; 
	int i = 1, ci = 2; 
	while(ci <= currentsize) 
	{ 
		if(ci < currentsize && heap[ci] > heap[ci + 1]) 
		{ 
			ci++; 
		} 

		if(y <= heap[ci]) 
		{ 
			break; 
		} 
		heap[i] = heap[ci]; 
		i = ci; 
		ci *= 2; 
	} 

	heap[i] = y; 
	return *this; 
} 

template<class T> 
void MinHeap<T>::Initialize(T x[], int size, int ArraySize) 
{ 
	delete []heap; 
	heap = x; 
	currentsize = size; 
	maxsize = ArraySize; 

	for(int i = currentsize / 2; i >= 1; i--) 
	{ 
		T y = heap[i]; 
		int c = 2 * i; 
		while(c <= currentsize) 
		{ 
			if(c < currentsize && heap[c] > heap[c + 1]) 
				c++; 
			if(y <= heap[c]) 
				break; 
			heap[c / 2] = heap[c]; 
			c *= 2; 
		} 
		heap[c / 2] = y; 
	} 
} 

template<class T> 
void MinHeap<T>::Deactivate() 
{ 
	heap = 0; 
} 

//批作業排程問題 優先佇列分支限界法求解 
#include "stdafx.h"
#include "MinHeap2.h"
#include <iostream>
using namespace std;

class Flowshop;
class MinHeapNode
{
	friend Flowshop;
	public:
		operator int() const
		{
			return bb;
		}
	private:	
		void Init(int);
		void NewNode(MinHeapNode,int,int,int,int);
		int s,			//已安排作業數
			f1,			//機器1上最後完成時間
			f2,			//機器2上最後完成時間
			sf2,		//當前機器2上完成時間和
			bb,			//當前完成時間和下界
			*x;			//當前作業排程
};

class Flowshop
{
	friend int main(void);
	public:
		int BBFlow(void);
	private:
		int Bound(MinHeapNode E,int &f1,int &f2,bool **y);
		void Sort(void);
		int n,			//作業數
			** M,		//各作業所需的處理時間陣列
			**b,		//各作業所需的處理時間排序陣列
			**a,		//陣列M和b的對應關係陣列
			*bestx,		//最優解
			bestc;		//最小完成時間和
		bool **y;		//工作陣列
};

template <class Type>
inline void Swap(Type &a, Type &b);

int main()
{
	int n=3,bf;
	int M1[3][2]={{2,1},{3,1},{2,3}};

	int **M = new int*[n];
	int **b = new int*[n];
	int **a = new int*[n];
	bool **y = new bool*[n];
	int *bestx = new int[n];  

    for(int i=0;i<=n;i++)
	{
        M[i] = new int[2];
		b[i] = new int[2];
		a[i] = new int[2];
		y[i] = new bool[2];
	}
	cout<<"各作業所需要的時間處理陣列M(i,j)值如下："<<endl;

	for(int i=0;i<n;i++)
	{
		for(int j=0;j<2;j++)
		{
			M[i][j]=M1[i][j];
		}
	}

    for(int i=0;i<n;i++)
	{
		cout<<"(";
		for(int j=0;j<2;j++)
		cout<<M[i][j]<<" ";
		cout<<")";
	}
	cout<<endl;

	Flowshop flow;
	flow.n = n;
	flow.M = M;
	flow.b = b;
	flow.a = a;
	flow.y = y;
	flow.bestx = bestx;
	flow.bestc = 1000;//給初值

	flow.BBFlow();

	cout<<"最優值是："<<flow.bestc<<endl;
	cout<<"最優排程是：";

	for(int i=0;i<n;i++)
	{
		cout<<(flow.bestx[i]+1)<<" ";
	}
	cout<<endl;

	for(int i=0;i<n;i++)
	{
		delete[] M[i];
		delete[] b[i];
		delete[] a[i];
		delete[] y[i];		
	}
	return 0;
}

//最小堆節點初始化
void MinHeapNode::Init(int n)
{
	x = new int[n];
	for(int i=0; i<n; i++)
	{
		x[i] = i;
	}
	s = 0;
	f1 = 0;
	f2 = 0;
	sf2 = 0;
	bb = 0;
}

//最小堆新節點
void MinHeapNode::NewNode(MinHeapNode E,int Ef1,int Ef2,int Ebb,int n)
{
	x = new int[n];
	for(int i=0; i<n; i++)
	{
		x[i] = E.x[i];
	}
	f1 = Ef1;
	f2 = Ef2;
	sf2 = E.sf2 + f2;
	bb = Ebb;
	s =  E.s + 1;
}

//對各作業在機器1和2上所需時間排序
void Flowshop::Sort(void)
{
	int *c = new int[n];
	for(int j=0; j<2; j++)
	{
		for(int i=0; i<n; i++)
		{
			b[i][j] = M[i][j];
			c[i] = i;
		}

		for(int i=0; i<n-1; i++)
		{
			for(int k=n-1; k>i; k--)
			{
				if(b[k][j]<b[k-1][j])
				{
					Swap(b[k][j],b[k-1][j]);
					Swap(c[k],c[k-1]);
				}
			}
		}	

		for(int i=0; i<n; i++)
		{
			a[c[i]][j] = i;
		}
	}

	delete []c;
}

//計算完成時間和下界
int Flowshop::Bound(MinHeapNode E,int &f1,int &f2,bool **y)
{
	for(int k=0; k<n; k++)
	{
		for(int j=0; j<2; j++)
		{	
			y[k][j] = false;
		}
	}

	for(int k=0; k<=E.s; k++)
	{
		for(int j=0; j<2; j++)
		{
			y[a[E.x[k]][j]][j] = true;
		}
	}

	f1 = E.f1 + M[E.x[E.s]][0];
	f2 = ((f1>E.f2)?f1:E.f2)+M[E.x[E.s]][1];
	int sf2 = E.sf2 + f2;
	int s1 = 0,s2 = 0,k1 = n-E.s,k2 = n-E.s,f3 = f2;

	//計算s1的值
	for(int j=0; j<n; j++)
	{
		if(!y[j][0])
		{
			k1--;
			if(k1 == n-E.s-1)
			{
				f3 = (f2>f1+b[j][0])?f2:f1+b[j][0];
			}
			s1 += f1+k1*b[j][0];
		}
	}

	//計算s2的值
	for(int j=0; j<n; j++)
	{	
		if(!y[j][1])
		{
			k2--;
			s1 += b[j][1];
			s2 += f3 + k2*b[j][1];
		}
	}

	//返回完成時間和下界
	return sf2 +((s1>s2)?s1:s2);
}

//解批處理作業排程問題的優先佇列式分支限界法
int Flowshop::BBFlow(void)
{
	Sort();//對各作業在機器1和2上所需時間排序
	MinHeap<MinHeapNode> H(1000);

	MinHeapNode E;
	//初始化
	E.Init(n);
	//搜尋排列空間樹
	while(E.s<=n)
	{
		//葉節點
		if(E.s == n)
		{
			if(E.sf2<bestc)
			{
				bestc = E.sf2;
				for(int i=0; i<n; i++)
				{
					bestx[i] = E.x[i];
				}
			}
			delete []E.x;
		}
		else//產生當前擴充套件節點的兒子節點
		{
			for(int i=E.s; i<n; i++)
			{
				Swap(E.x[E.s],E.x[i]);
				int f1,f2;
				int bb = Bound(E,f1,f2,y);
				if(bb<bestc)
				{
					//子樹可能含有最優解
					//節點插入最小堆
					MinHeapNode N;
					N.NewNode(E,f1,f2,bb,n);
					H.Insert(N);
				}
				Swap(E.x[E.s],E.x[i]);
			}
			delete []E.x;//完成節點擴充套件
		}
		if(H.Size() == 0)
		{
			break;
		}
		H.DeleteMin(E);//取下一擴充套件節點
	}
	return bestc;
}

template <class Type>
inline void Swap(Type &a, Type &b)
{ 
	Type temp=a; 
	a=b; 
	b=temp;
}