最佳调度问题.docx

最佳调度问题.docx

《最佳调度问题.docx》由会员分享，可在线阅读，更多相关《最佳调度问题.docx（6页珍藏版）》请在冰豆网上搜索。

实验八：

分支限界法最佳调度问题

一、实验目的与要求

1、掌握最佳调度问题的算法；

2、初步掌握分支限界法

二、实验题：

 问题描述：

假设有n个任务由k个可并行工作的机器完成。

完成任务i需要的时间为ti。

试设计一个算法找出完成这n个任务的最佳调度，使得完成全部任务的时间最早。

#include

#include

usingnamespacestd;

classMinHeapNode

{

friendclassFlowshop;

public:

booloperator<（constMinHeapNode&a）const{returna.bb

private:

voidInit（int）;

voidNewNode（MinHeapNode,int,int,int,int）;

ints;//已安排作业数

intf1;//机器1上最后完成时间

intf2;//机器2上最后完成时间

intsf2;//当前机器2上的完成时间和

intbb;//当前完成时间和下界

int*x;//当前作业调度

};

voidMinHeapNode:

:

Init（intn）

{//最小堆结点初始化

x=newint[n];

for（inti=0;i

x[i]=i;

s=0;

f1=0;

f2=0;

sf2=0;

bb=0;

}

voidMinHeapNode:

:

NewNode（MinHeapNodeE,intEf1,intEf2,intEbb,intn）

{//最小堆新结点

x=newint[n];

for（inti=0;i

x[i]=E.x[i];

f1=Ef1;

f2=Ef2;

sf2=E.sf2+f2;

bb=Ebb;

s=E.s+1;

}

classFlowshop

{

friendintmain（）;

public:

intBBFlow（）;

private:

Flowshop（intn）;//构造函数

~Flowshop（）;//析构函数

intBound（MinHeapNode,int&,int&,bool**）;

voidSort（）;

intn;

int**M;

int**b;

int**a;

int*bestx;

intbestc;

bool**y;

};

Flowshop:

:

Flowshop（intn）

{

//M=newint*[n];

b=newint*[n];

a=newint*[n];

y=newbool*[n];

bestx=newint[n];

bestc=10000;

for（inti=0;i

{

//M[i]=newint[2];

b[i]=newint[2];

a[i]=newint[2];

y[i]=newbool[2];

}

}

Flowshop:

:

~Flowshop（）

{

for（inti=0;i

{

delete[]M[i];

delete[]b[i];

delete[]a[i];

delete[]y[i];

}

deletebestx,M,b,a,y;

}

voidFlowshop:

:

Sort（）

{//对各作业在机器1和2上所需时间进行冒泡排序

int*c=newint[n];

for（intj=0;j<2;j++）

{

for（inti=0;i

{

b[i][j]=M[i][j];

c[i]=i;

}

for（i=0;i

for（intk=n-1;k>i;k--）

if（b[k][j]

{

swap（b[k][j],b[k-1][j]）;

swap（c[k],c[k-1]）;

}

for（i=0;i

a[c[i]][j]=i;

}

delete[]c;

}

intFlowshop:

:

Bound（MinHeapNodeE,int&f1,int&f2,bool**y）

{//计算完成时间和下界

for（intk=0;k

for（intj=0;j<2;j++）

y[k][j]=0;

for（k=0;k<=E.s;k++）

for（intj=0;j<2;j++）

y[a[E.x[k]][j]][j]=1;

f1=E.f1+M[E.x[E.s]][0];

f2=（（f1>E.f2）?

f1:

E.f2）+M[E.x[E.s]][1];

intsf2=E.sf2+f2;

ints1=0,s2=0,k1=n-E.s,k2=n-E.s,f3=f2;

//计算s1的值

for（intj=0;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（j=0;j

if（!

y[j][1]）

{

k2--;

s1+=b[j][1];

s2+=f3+k2*b[j][1];

}

//返回完成时间和下界

returnsf2+（（s1>s2）?

s1:

s2）;

}

intFlowshop:

:

BBFlow（）

{

Sort（）;

priority_queueH;

MinHeapNodeE;

E.Init（n）;

while（E.s<=n）

{

if（E.s==n）

{

if（E.sf2

{

bestc=E.sf2;

for（inti=0;i

bestx[i]=E.x[i];

}

delete[]E.x;

}

else

{

for（inti=E.s;i

{

swap（E.x[E.s],E.x[i]）;

intf1,f2;

intbb=Bound（E,f1,f2,y）;

if（bb

{

MinHeapNodeN;

N.NewNode（E,f1,f2,bb,n）;

H.push（N）;

}

swap（E.x[E.s],E.x[i]）;

}

delete[]E.x;

}

if（H.empty（））

break;

else

{

E=H.top（）;

H.pop（）;

}

}

returnbestc;

}

intmain（）

{

intn;

cout<<"输入作业数:

";

cin>>n;

int**M=newint*[n];

for（inti=0;i

M[i]=newint[2];

for（i=0;i

for（intj=0;j<2;j++）

{

cout<<"M["<

";

cin>>M[i][j];

}

FlowshopG（n）;

G.M=M;

G.n=n;

intf=G.BBFlow（）;

cout<<"最佳调度方案:

";

for（i=0;i

cout<

cout<

cout<<"最佳完成时间和:

"<

return0;

}