k:
0;
54.}
55.
56.
57.
58.
59.
60.void main（）
61.{
62. //定义任务图，采用二维数组表示所有节点间的关系，例如t1节点指向t2则node[1][2] = 4,而node[1][9] = 0，因为t1没有指向t9的路经
63. //由于没有节点t0则T[0][i]全部为0。
64. int i;
65. int j;
66. int node[10][10] = {0};
67. node[1][2] = 4;
68. node[1][3] = 1;
69. node[1][4] = 1;
70. node[1][5] = 1;
71. node[1][7] = 10;
72.
73. node[2][6] = 1;
74. node[2][7] = 1;
75.
76. node[3][8] = 1;
77.
78. node[4][8] = 1;
79.
80. node[6][9] = 5;
81.
82. node[7][9] = 6;
83.
84. node[8][9] = 5;
85./********************************************************************************/
86. //定义每一个节点的计算时间,忽略t[0]
87. int t[10];
88. t[1] = 2;
89. t[2] = 3;
90. t[3] = 3;
91. t[4] = 4;
92. t[5] = 5;
93. t[6] = 4;
94. t[7] = 4;
95. t[8] = 4;
96. t[9] = 1;
97./********************************************************************************/
98. //定义每一个节点的前导节点,例如节点8的前导节点为节点3、4，则diaodao[8][3] = 1，diandao[8][4] = 1
99. int qiandao[10][10] = {0};
100. qiandao[2][1] = 1;
101. qiandao[3][1] = 1;
102. qiandao[4][1] = 1;
103. qiandao[5][1] = 1;
104. qiandao[7][1] = 1;
105. qiandao[6][2] = 1;
106. qiandao[7][2] = 1;
107. qiandao[8][3] = 1;
108. qiandao[8][4] = 1;
109. qiandao[9][6] = 1;
110. qiandao[9][7] = 1;
111. qiandao[9][8] = 1;
112.
113./********************************************************************************/
114. //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
115. //所以从尾节点倒序计算每一个节点的b_level值。
116. int b_level[10] = {0};
117. //尾节点b_level值为0
118. b_level[5] = 5;
119. b_level[9] = 1;
120. //指示是否已经计算过b_level值
121. int b_cal[10] = {0};
122. b_cal[5] = 1;
123. b_cal[9] = 1;
124. int b_level_max, temp1, temp2, temp;
125.
126. //从节点t1开始计算b_level值
127.
128. //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
129. for（int i = 1; i < 10; i++）
130. if（qiandao[9][i] == 1）
131. b_level[i] = t[9] + t[i] + node[i][9];
132.
133. //计算倒数第二排节点
134. for（int i = 1; i < 9; i++）
135. {
136. if（b_level[i] !
= 0）
137. {
138. for（int j = 1; j < 10; j++）
139. if（qiandao[i][j] == 1）
140. {
141. temp1 = t[j] + node[j][i] + b_level[i];
142. if（temp1 > b_level[j]）
143. b_level[j] = temp1;
144. }
145. }
146. }
147. //最后计算t1节点
148. for（int i = 1; i < 10; i++）
149. {
150. if（qiandao[i][1] == 1）
151. {
152. temp1 = t[1] + node[1][i] + b_level[i];
153. if（temp1 > b_level[1]）
154. b_level[1] = temp1;
155. }
156.
157. }
158.
159.
160./********************************************************************************/
161.
162.
163./********************************************************************************/
164. //计算b_level值,忽略b_level[0],由于事先已知头节点和尾节点（在本例中头节点为t1，尾节点为t5和t9）
165. //所以从尾节点倒序计算每一个节点的b_level值。
166. int SBL[10] = {0};
167. //尾节点b_level值为0
168. SBL[5] = 5;
169. SBL[9] = 1;
170. //指示是否已经计算过b_level值
171. int SBL_cal[10] = {0};
172. SBL_cal[5] = 1;
173. SBL_cal[9] = 1;
174. int SBL_max, SBL_temp1, SBL_temp2, SBL_temp;
175.
176. //从节点t1开始计算b_level值
177.
178. //从尾节点9开始倒序计算b_level值，直到头节点1结束，由于最多有三次向前计算的机会，所以算三次就结束。
179. for（int i = 1; i < 10; i++）
180. if（qiandao[9][i] == 1）
181. SBL[i] =t[9] + t[i] ;
182.
183. //计算倒数第二排节点
184. for（int i = 1; i < 9; i++）
185. {
186. if（SBL[i] !
= 0）
187. {
188. for（int j = 1; j < 10; j++）
189. if（qiandao[i][j] == 1）
190. {
191. SBL_temp1 = t[j] + SBL[i];
192. if（SBL_temp1 > SBL[j]）
193. SBL[j] = SBL_temp1;
194. }
195. }
196. }
197. //最后计算t1节点
198. for（int i = 1; i < 10; i++）
199. {
200. if（qiandao[i][1] == 1）
201. {
202. SBL_temp1 =t[1] + SBL[i];
203. if（SBL_temp1 > SBL[1]）
204. SBL[1] = SBL_temp1;
205. }
206.
207. }
208.
209.
210.
211.
212.//计算每个节点的前向大数
213. int qian_max[10] = {0};
214. for（i = 1; i < 10; i++）
215. {
216. temp1 = 0;
217. for（int j = 0; j < 10; j++）
218. {
219. if（node[j][i] > qian_max[i]）
220. qian_max[i] = node[j][i];
221. }
222.
223. }
224./////////////////////////////////////////////////////////////////////////////////////////////////////
225.//计算节点t1到其他所有节点的最大路径值
226. int t_level[10] = {0};
227. for（i = 1; i < 10; i++）
228. {
229. if（node[1][i] !
= 0）
230. {
231. t_level[i] = t[1] + node[1][i];
232. if（t_level[i] < temp1）
233. t_level[i] = temp1;
234. for（int j = 1; j < 10; j++）
235. {
236. if（node[i][j] !
= 0）
237. {
238. t_level[j] = t_level[i] + node[i][j]+t[i];
239. for（int k = 1; k < 10; k++）
240. {
241. if（node[j][k] !
= 0）
242. t_level[k] = t_level[j] + node[j][k];
243.
244. }
245. }
246. }
247. }
248. }
249.
250. for（i = 1; i < 10; i++）
251. printf（"t_level[%d] = %d/n", i, t_level[i]）;
252.
253.
254. for（i = 1; i < 10; i++）
255. printf（"sbl[%d] = %d/n", i, SBL[i]）;
256.
257.
258. for（i = 1; i < 10; i++）
259. printf（"qian_max[%d] = %d/n", i, qian_max[i]）;
260.
261. for（i = 1; i < 10; i++）
262. {printf（"b_level[%d]:
%d/n ",i, b_level[i]）;}
263.
264.
265.
266.
267.
268.
269.
270.
271.
272.////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////ISH
273. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
274.
275.int pe[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的开始时间，如pe[i]=x表示i任务开始执行时间为x
276.int time[4]={0,0,0,0}; //记录机器当前时间，其值为当前分配的任务开始时间+任务的执行时间
277.
278.int tdispatched[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};//记录任务的分配情况，如tdispatched[i]=x表示i任务被分配到x号机器上
279.
280.
281.for（i=1;i<10;i++） //从9个任务里面，按sbl的降序取值
282.
283.{
284.int maxid=max（SBL）;
285.
286.SBL[maxid]=0;
287.
288.//=========================================================================================分配maxid开始
289.
290.
291.
292.if（maxid==1）{
293.
294. pe[maxid]=0;
295. tdispatched[maxid]=0;
296. time[0]+=t[maxid];//0号机器被用掉的时间为该任务的运行耗时
297.
298.
299.
300. }else{
301.
302.
303.
304.
305.
306.
307.
308. int early[4]={-1,-1,-1,-1};//记录一个任务如果分配到0-3号机器能够最早执行的时间
309.
310.int a[4]={-1,-1,-1,-1};//记录由各个父节点产生的开始时间限制（包括同机器无通信时间情况与非同机器有通信时间情况）
311. for（int machid=0;machid<4;machid++）//往4台机器上分
312. {
313. int j=1;
314. a[0]=-1;
315. a[1]=-1;
316. a[2]=-1;
317. a[3]=
升级会员 