多处最优问题

算法实现题4-7 多处最优服务次序问题

问题描述：

设有n 个顾客同时等待一项服务。顾客i需要的服务时间为ti, 1≦i ≦n 。共有s处可以提供此服务。应如何安排n个顾客的服务次序才能使平均等待时间达到最小?平均等待时间是n 个顾客等待服务时间的总和除以n。

编程任务：

对于给定的n个顾客需要的服务时间和s的值，编程计算最优服务次序。

数据输入：

由文件input.txt给出输入数据。第一行有2 个正整数n 和s，表示有n 个顾客且有s 处可以提供顾客需要的服务。接下来的1 行中，有n个正整数，表示n个顾客需要的服务时间。

结果输出:

　　将编程计算出的最小平均等待时间输出到文件output.txt。

输入示例

input.txt

10 2

56 12 199 1000 234 33 55 99 812

输出示例

output.txt

336

 

 

#include<iostream>

#include<iomanip>

usingnamespace std;

typedefstruct Job

{

       int ID;

       int time;

}Job;

typedefstruct JobNode

{

       int ID;

       int time;

       JobNode *next;

}JobNode,*pJobNode;

typedefstruct Header

{

       int s;

       JobNode *next;

}Header,pHeader;

intmain()

{

       void QuickSort(Job *job,int left,intright);

       void outSort(Job *job,int n);

       void display(Header *M,int m,int n);

       void solve(Header *head,Job *job,intn,int m);

       int m,n;

       cout<<"\t\t<多处最优服务问题>\n";

       cout<<"请输入机器的数量:";

       cin>>m;

       Header *head= new Header[m];

       cout <<"请输入作业个数：";

       cin>>n;

       Job *job = new Job[n];

       cout<<"\n请按序号输入每个作业调度需要的时间:";

       for(int i=0;i<n;i++)

       {

              cin>>job[i].time;

              job[i].ID=i;

       }

 

       QuickSort(job,0,n-1);

      

       outSort(job,n);

       solve(head,job,n,m);

       display(head,m,n);

       cout<<endl<<endl;

       return 0;

}

intSelectMin(Header *M,int m)

{

       int k=0;

       for(int i=1;i<m;i++)

       {

              if(M[i].s<M[k].s)

              {

                     k=i;

              }

             

       }

       return k;

}

voidQuickSort(Job *job,int left,int right)

{

       int middle=0,i=left,j=right;

       Job itemp;

       middle=job[(left+right)/2].time;

       do

       {

              while((job[i].time<middle)&&(i<right))i++;

              while((job[j].time>middle)&&(j>left))j--;

              if(i<=j)

              {

                     itemp = job[j];

                     job[j] = job[i];

                     job[i] = itemp;

                     i++;

                     j--;

              }

 

       }while(i<=j);

       if(left<j) QuickSort(job,left,j);

       if(right>i) QuickSort(job,i,right);

}

voiddisplay(Header *M,int m,int n)

{

       int *total = new int[m];

       int *current= new int[m];

       for(int j=0;j<m;j++)

       {

              total[j]=0;

       }

       for(j=0;j<m;j++)

       {

              current[j]=0;

       }

       double average=0;

       JobNode *p;

       for(int i=0;i<m;i++)

       {

 

              cout<<"\n第"<<i<<"台机器上处理的工作序号:";

              if(M[i].next == 0)

                     continue;

              p=M[i].next;

              do{

                     cout<<p->ID<<"\t";

                     current[i] =current[i]+p->time;

                     total[i]=total[i]+current[i];

                     //cout<<"("<<total[i]<<")";

                    

                     p=p->next;

              }while(p!=0);

      

       }

       cout<<endl;

       for(j=0;j<m;j++)

       {

              average+=total[j];

       }

       cout<<"平均时间："<<average/n;

}

voidoutSort(Job *job,int n)

{

       cout<<"\n按工作时间由小到大为:\n时间:\t";

       for(int i=0;i<n;i++)

       {

              cout<<setw(4)<<job[i].time;

       }

       cout<<"\n序号:\t";

       for(i=0;i<n;i++)

       {

              cout<<setw(4)<<job[i].ID;

       }

}

voidsolve(Header *head,Job *job,int n,int m)

{

       int k;

       for (int i=0;i<m&&i<n;i++)

       {

              JobNode *jobnode = new JobNode;

              jobnode->time = job[i].time;

              jobnode->ID = job[i].ID;

              jobnode->next= 0;

              head[i].s = jobnode->time;

              head[i].next=jobnode;

       }

       if(i<=m)

       {

              for(i;i<m;i++)

              {

             

                     head[i].s =0;

                     head[i].next=0;

              }

       }

       if(n>m)

       {

              for(i;i<n;i++)

              {

                     JobNode *p;

                     JobNode *jobnode = newJobNode;

                     jobnode->time =job[i].time;

                     jobnode->ID = job[i].ID;

                     jobnode->next = 0;

                     k = SelectMin(head,m);

                     p = head[k].next;

                     head[k].s +=jobnode->time;

                     while(p->next!=0)

                     {

                            p=p->next;

                           

                     }

                     p->next=jobnode;

              }

       }

}

 

 

 

(注解:很多人会对这道题中平均等待服务时间不理解,下面我解释一下变做出这道题的具体运算过程.

 

一个顾客的等待服务时间是顾客的等待时间加上这个顾客的服务时间,学过操作系统的同学应该明白进程的周转时间吧, 说的好像只有顾客的等待时间而没有服务时间，这也是悲催的原因吧。

 

下面说下此程序的运算过程：

队列1