分支限界法批处理调度问题.docx
《分支限界法批处理调度问题.docx》由会员分享,可在线阅读,更多相关《分支限界法批处理调度问题.docx(20页珍藏版)》请在冰豆网上搜索。
![分支限界法批处理调度问题.docx](https://file1.bdocx.com/fileroot1/2023-2/21/f04830fd-fe01-42df-9532-2d5ae0cddc74/f04830fd-fe01-42df-9532-2d5ae0cddc741.gif)
分支限界法批处理调度问题
【分支限界法】批处理作业调度问题
问题描述
给定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)个作业完成时间和都得算上t1pk。
如果不能做到上面这一点,则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)首先考虑=n的情形,当前扩展结点E是排列树中的叶结点。
是相应于该叶结点的完成时间和。
当
2)当对于当前扩展结点的每一个儿子结点node,计算出其相应的完成时间和的下界bb。
当bb而当bbbestc时,可将结点node舍去。
算法具体实现如下:
1.#include
2.
3.template
4.class Graph;
5.
6.template
7.class MinHeap
8.{
9. template
10. friend class Graph;
11. public:
12. MinHeap(int maxheapsize = 10);
13. ~MinHeap(){delete []heap;}
14.
15. int Size() const{return currentsize;}
16. T Max(){if(currentsize) return heap[1];}
17.
18. MinHeap& Insert(const T& x);
19. MinHeap& DeleteMin(T &x);
20.
21. void Initialize(T x[], int size, int ArraySize);
22. void Deactivate();
23. void output(T a[],int n);
24. private:
25. int currentsize, maxsize;
26. T *heap;
27.};
28.
29.template
30.void MinHeap:
:
output(T a[],int n)
31.{
32. for(int i = 1; i <= n; i++)
33. cout << a[i] << " ";
34. cout << endl;
35.}
36.
37.template
38.MinHeap:
:
MinHeap(int maxheapsize)
39.{
40. maxsize = maxheapsize;
41. heap = new T[maxsize + 1];
42. currentsize = 0;
43.}
44.
45.template
46.MinHeap& MinHeap:
:
Insert(const T& x)
47.{
48. if(currentsize == maxsize)
49. {
50. return *this;
51. }
52. int i = ++currentsize;
53. while(i !
= 1 && x < heap[i/2])
54. {
55. heap[i] = heap[i/2];
56. i /= 2;
57. }
58.
59. heap[i] = x;
60. return *this;
61.}
62.
63.template
64.MinHeap& MinHeap:
:
DeleteMin(T& x)
65.{
66. if(currentsize == 0)
67. {
68. cout<<"Empty heap!
"<69. return *this;
70. }
71.
72. x = heap[1];
73.
74. T y = heap[currentsize--];
75. int i = 1, ci = 2;
76. while(ci <= currentsize)
77. {
78. if(ci < currentsize && heap[ci] > heap[ci + 1])
79. {
80. ci++;
81. }
82.
83. if(y <= heap[ci])
84. {
85. break;
86. }
87. heap[i] = heap[ci];
88. i = ci;
89. ci *= 2;
90. }
91.
92. heap[i] = y;
93. return *this;
94.}
95.
96.template
97.void MinHeap:
:
Initialize(T x[], int size, int ArraySize)
98.{
99. delete []heap;
100. heap = x;
101. currentsize = size;
102. maxsize = ArraySize;
103.
104. for(int i = currentsize / 2; i >= 1; i--)
105. {
106. T y = heap[i];
107. int c = 2 * i;
108. while(c <= currentsize)
109. {
110. if(c < currentsize && heap[c] > heap[c + 1])
111. c++;
112. if(y <= heap[c])
113. break;
114. heap[c / 2] = heap[c];
115. c *= 2;
116. }
117. heap[c / 2] = y;
118. }
119.}
120.
121.template
122.void MinHeap:
:
Deactivate()
123.{
124. heap = 0;
125.}
2、
1.//批作业调度问题 优先队列分支限界法求解
2.#include ""
3.#include ""
4.#include
5.using namespace std;
6.
7.class Flowshop;
8.class MinHeapNode
9.{
10. friend Flowshop;
11. public:
12. operator int() const
13. {
14. return bb;
15. }
16. private:
17. void Init(int);
18. void NewNode(MinHeapNode,int,int,int,int);
19. int s, //已安排作业数
20. f1, //机器1上最后完成时间
21. f2, //机器2上最后完成时间
22. sf2, //当前机器2上完成时间和
23. bb, //当前完成时间和下界
24. *x; //当前作业调度
25.};
26.
27.class Flowshop
28.{
29. friend int main(void);
30. public:
31. int BBFlow(void);
32. private:
33. int Bound(MinHeapNode E,int &f1,int &f2,bool **y);
34. void Sort(void);
35. int n, //作业数
36. ** M, //各作业所需的处理时间数组
37. **b, //各作业所需的处理时间排序数组
38. **a, //数组M和b的对应关系数组
39. *bestx, //最优解
40. bestc; //最小完成时间和
41. bool **y; //工作数组
42.};
43.
44.template
45.inline void Swap(Type &a, Type &b);
46.
47.int main()
48.{
49. int n=3,bf;
50. int M1[3][2]={{2,1},{3,1},{2,3}};
51.
52. int **M = new int*[n];
53. int **b = new int*[n];
54. int **a = new int*[n];
55. bool **y = new bool*[n];
56. int *bestx = new int[n];
57.
58. for(int i=0;i<=n;i++)
59. {
60. M[i] = new int[2];
61. b[i] = new int[2];
62. a[i] = new int[2];
63. y[i] = new bool[2];
64. }
65. cout<<"各作业所需要的时间处理数组M(i,j)值如下:
"<66.
67. for(int i=0;i68. {
69. for(int j=0;j<2;j++)
70. {
71. M[i][j]=M1[i][j];
72. }
73. }
74.
75. for(int i=0;i76. {
77. cout<<"(";
78. for(int j=0;j<2;j++)
79. cout<80. cout<<")";
81. }
82. cout<83.
84. Flowshop flow;
85. = n;
86. = M;
87. = b;
88. = a;
89. = y;
90. = bestx;
91. = 1000;//给初值
92.
93. ();
94.
95. cout<<"最优值是:
"<<<96. cout<<"最优调度是:
";
97.
98. for(int i=0;i99. {
100. cout<<[i]+1)<<" ";
101. }
102. cout<103.
104. for(int i=0;i105. {
106. delete[] M[i];
107. delete[] b[i];
108. delete[] a[i];
109. delete[] y[i];
110. }
111. return 0;
112.}
113.
114.//最小堆节点初始化
115.void MinHeapNode:
:
Init(int n)
116.{
117. x = new int[n];
118. for(int i=0; i119. {
120. x[i] = i;
121. }
122. s = 0;
123. f1 = 0;
124. f2 = 0;
125. sf2 = 0;
126. bb = 0;
127.}
128.
129.//最小堆新节点
130.void MinHeapNode:
:
NewNode(MinHeapNode E,int Ef1,int Ef2,int Ebb,int n)
131.{
132. x = new int[n];
133. for(int i=0; i134. {
135. x[i] = [i];
136. }
137. f1 = Ef1;
138. f2 = Ef2;
139. sf2 = + f2;
140. bb = Ebb;
141. s = + 1;
142.}
143.
144.//对各作业在机器1和2上所需时间排序
145.void Flowshop:
:
Sort(void)
146.{
147. int *c = new int[n];
148. for(int j=0; j<2; j++)
149. {
150. for(int i=0; i151. {
152. b[i][j] = M[i][j];
153. c[i] = i;
154. }
155.
156. for(int i=0; i157. {
158. for(int k=n-1; k>i; k--)
159. {
160. if(b[k][j]
161. {
162. Swap(b[k][j],b[k-1][j]);
163. Swap(c[k],c[k-1]);
164. }
165. }
166. }
167.
168. for(int i=0; i169. {
170. a[c[i]][j] = i;
171. }
172. }
173.
174. delete []c;
175.}
176.
177.//计算完成时间和下界
178.int Flowshop:
:
Bound(MinHeapNode E,int &f1,int &f2,bool **y)
179.{
180. for(int k=0; k181. {
182. for(int j=0; j<2; j++)
183. {
184. y[k][j] = false;
185. }
186. }
187.
188. for(int k=0; k<=; k++)
189. {
190. for(int j=0; j<2; j++)
191. {
192. y[a[[k]][j]][j] = true;
193. }
194. }
195.
196. f1 = + M[[]][0];
197. f2 = ((f1>f1:
+M[[]][1];
198. int sf2 = + f2;
199. int s1 = 0,s2 = 0,k1 = ,k2 = ,f3 = f2;
200.
201. //计算s1的值
202. for(int j=0; j