贪心法设计一种更快的作业排序算法(转)

算法设计思想:如果J是作业的可行子集,那么可以使用下述规则来确定这些作业中的每一个作业的处理时间:若还没给作业i分配处理时间,则分配给它时间片[a-1,a],其中a应尽量取最大且时间片[a-1,a]是空的。此规则就是尽可能推迟对作业i的处理。于是,在将作业一个一个地装配到J中时,不必为接纳新作业而去移动J中那些已分配了时间片的作业。如果正被考虑的新作业不存在像上面那样定义的a,这个作业就不能计人J。各作业的效益值放在P[   ]中,并按效益值非增次序排列,期限值放在D[   ]中,F[   ]用于存放最大期限值,J[   ]用于存放最优解,Q[   ]用于存放作业的调度次序。

算法描述:
line   procedure     FJS(D,n,b,j,   k)    
          //找最优解J=J(1),…J(K)//
            //D(1),…..,D(n)是期限值,n> =1.作业已按//P(1)> =P(2)> =….P(n)被排序,//b=min{n,max{D(i)}}//
integer   b,i,k,n,j   ,l,D(n),J(n),F(0:b),p(0:b)
for   i=1to   n   do         //将树置初值//
              F(i)ßi;p(i)ß-1
repeat
Kß0         //初始化J//
for     iß1   to     n     do           //使用贪心规则//
                jß   FIND(min(n,D(i)   ))
                if   F(j)不为0   then   kßk+1;J(K)ßi         //选择作业   i//
                                    lßFIND(F(j)-1);   call   UNION(l,j)
                                    F(j)ßF(1)
              endif
repeat
end   FJS

算法分析:此算法的时间复杂度为:O(na(2n,n))(Ackerman函数的逆函数。);
     它用于F和P的空间至多为2n个字节。

完整的代码(C语言):
#include <stdio.h>
#include <malloc.h>

int   FIND(int   *parent,int   i)
{//查找含有元素i的树根,使用压缩规则去压缩由i到根j的所有结点
int   j,k,t;
j=i;
while(parent[j]> 0)   j=parent[j];//找根
k=i;
while(k!=j){//压缩由i到根j的结点
t=parent[k];
parent[k]=j;
k=t;
}
return   j;
}

void   UNION(int   *parent,int   i,int   j)
{//使用加权规则合并根为i和j的两个集合
int   x;
x=parent[i]+parent[j];
if(parent[i]> parent[j]){//i的结点少
parent[i]=j;
parent[j]=x;
}
else{//j的结点少
parent[j]=i;
parent[i]=x;
}
}

int   MIN(int   n,int   m)                                                    
{//求n和m的最小值
if(n> m)   return   m;
else         return   n;
}

int   FJS(int   *D,int   n,int   b,int   *J,int   *Q)
{//找J(n)的最优解,并返回最优解的个数
int   i,*F,*p,j,l,m,k;
F=(int   *)malloc((b+1)*sizeof(int));
p=(int   *)malloc((b+1)*sizeof(int));
        for(i=0;i <=b;i++){//将树置初值
F[i]=i;
p[i]=-1;
}
k=0;//初始化J
for(i=1;i <=n;i++)
{//使用贪心规则
j=FIND(p,MIN(n,D[i]));
if(F[j]!=0)
{//选择作业i
k=k+1;
J[k]=i;
        Q[F[j]]=i;
m=F[j];
l=FIND(p,F[j]-1);
UNION(p,l,j);
F[j]=F[l];
}
}
return   k;//返回最优解的个数
}


int   MAXMUM(int   i,int   j)
{//求i和j的最大值
if(i> j)   return   i;
else     return     j;
}

int   MAX(int   *D,int   i,   int   j)
{//D(1:n)是含有n个元素数组,求出D(i,j)中的最大值并返回
int   max,mid,max1,max2;
if(i==j)     max=D[i];
        else
if(i==j-1)    
if(D[i] <D[j])     max=D[j];
else   max=D[i];
else{
mid=(i+j)/2;
max1=MAX(D,i,mid);
max2=MAX(D,mid+1,j);
max=MAXMUM(max1,max2);
}
return   max;
}

void   Insertionsort(int   *D,int   n)
{//将D中的元素按非增次序分类
int   j,item,i;
D[0]=65525;   //设置监视哨
for(j=2;j <=n;j++){
item=D[j];
i=j-1;
while(item> D[i]){
D[i+1]=D[i];
i=i-1;
}
D[i+1]=item;

}

}

void   main()
{
int   *D,*J,*Q,*p,n,b,i,k;
                printf( "\n   *******************用贪心法解决带有限期的作业排序问题************************\n ");
printf( "\n请输入作业的数目:\n ");
scanf( "%d ",&n);
D=(int*)malloc((n+1)*sizeof(int));
p=(int*)malloc((n+1)*sizeof(int));
        printf( "\n请输入每个作业的效益值(%d个): ",n);
for(i=1;i <=n;i++)
scanf( "%d ",&p[i]);
Insertionsort(p,n);
printf( "\n按效益值非增排序后各作业为:\n ");
        printf( "\n作业序号                   效益值\n ");
        for(i=1;i <=n;i++)
printf( "J%d                               %d\n ",i,p[i]);
printf( "\n ");
printf( "\n请输入按效益值非增排序后各作业的截止时间(%d个): ",n);
for(i=1;i <=n;i++)
scanf( "%d ",&D[i]);
b=MIN(n,MAX(D,1,n));
        J=(int*)malloc((b+1)*sizeof(int));
Q=(int*)malloc((b+1)*sizeof(int));
        for(i=1;i <=b;i++)
Q[i]=-1;
k=FJS(D,n,b,J,Q);
printf( "\n\n************************本问题的最优解*****************************\n\n ");
        printf( "\n作业序号                   效益值\n ");
        for(i=1;i <=k;i++)
printf( "J%d                               %d\n ",J[i],p[i]);
printf( "\n\n************************各作业的执行次序******************************\n ");
printf( "\n作业序号                   效益值\n ");
        for(i=1;i <=b;i++)
if(Q[i]!=-1)
            printf( "J%d                               %d\n ",Q[i],p[i]);
printf( "\n\n ");

}

希望和大家一起分享和讨论!

http://topic.csdn.net/t/20050422/22/3959789.html

posted @ 2011-03-08 21:34  SunnyDay2015  阅读(3176)  评论(0编辑  收藏  举报