算法实验四-贪心算法

---

实验目的

理解贪心算法的思想，并能对给定的问题能设计出分治算法予以解决。

---

正文内容：

一、最优服务次序问题

1.问题描述：

设有n个顾客同时等待一项服务，顾客i需要的服务时间为ti，（1<=i<=n）。应如何安排n个顾客的服务次序才能使平均等待时间达到最小？（平均等待时间是n个顾客等待服务时间总和除以n）
输入：第一行为一个正整数n，表示有n个顾客
第二行为n个正整数，表示n个顾客需要的服务时间
输出：最小平均等待时间。
代码实现：

#include<iostream>
#include <vector>
#include<algorithm> 
using namespace std;
using std::vector;
double greedy(vector<int>x,int s)
{
 vector<int>st(s+1,0);
 vector<int>su(s+1,0);
 int n=x.size();
 sort(x.begin(),x.end());
 int i=0,j=0;
 while(i<n){
	 st[j]+=x[i];
	 su[j]+=st[j];
	 i++;
	 j++;
	 if(j==s)j=0;
 }
double t=0;
for(i=0;i<s;i++) t+=su[i];
t/=n;
return t;
}
void  main()
{int n;
 int s=1;
 int i;
 int a;
 int t;
 vector<int>x;
 cin>>n;
 for(i=1;i<=n;i++){
	 cin>>a;
	 x.push_back(a);
 }
 t=greedy(x, s);
 cout<<t<<endl;		
}

2.实验结果：

二、多处最优服务次序问题

1.问题描述：

设有n个顾客同时等待一项服务，顾客i需要的服务时间为ti，（1<=i<=n）。共有s处可以提供此项服务。应如何安排n个顾客的服务次序才能使平均等待时间达到最小？
输入：第一行为两个正整数n和s
第二行为n个正整数，表示n个顾客需要的服务时间
输出：最小平均等待时间。
代码实现：

#include<iostream>
#include <vector>
#include<algorithm> 
using namespace std;
using std::vector;
double greedy(vector<int>x,int s)
{
 vector<int>st(s+1,0);
 vector<int>su(s+1,0);
 int n=x.size();
 sort(x.begin(),x.end());
 int i=0,j=0;
 while(i<n){
	 st[j]+=x[i];
	 su[j]+=st[j];
	 i++;
	 j++;
	 if(j==s)j=0;
 }
double t=0;
for(i=0;i<s;i++) t+=su[i];
t/=n;
return t;
}
void  main()
{int n;
 int s;
 int i;
 int a;
 int t;
 vector<int>x;
 cin>>n;
 cin>>s;
 for(i=1;i<=n;i++){
	 cin>>a;
	 x.push_back(a);
 }
 t=greedy(x, s);
 cout<<t<<endl;		
}

2.实验结果：

三、最优分解问题

1.问题描述：

设n是一个正整数，要求将n分解为若干互不相同的自然数之和，且这些自然数的乘积最大。
输入：正整数n
输出：计算的最大乘积。
如输入10，则输出30.
提示：若a+b=const ，则a-b的绝对值越小，ab值越大。贪心策略：将n分成从2开始的连续自然数之和，如果最后剩下一个数，则将此数在后项优先的方式下均匀地分给前面各项。
代码实现：

#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
int main()
{
int i,num3,num4,n,s=0;
priority_queue<int,vector<int>,less<int> > a;
cin>>n;
for(i=2;;i++)
{
s+=i;
a.push(i);
if(s>n)
{
int num2=a.top();
a.pop();
s-=num2;
num3=n-s;
num4=a.top();
break;
}
}
int b[200],len;
 
for(i=0;!a.empty();i++)
{
    b[i]=a.top();
    a.pop();
}
 
len=i;
sort(b,b+len);
int j=0;
 
while(1)
{
if(b[j]+num3>num4)
    break;
j++;
}
 
b[j]=b[j]+num3;
 
sort(b,b+len);
 
int sum=1;
for(i=0;i<len;i++)
    sum*=b[i];
    cout<<sum<<endl;
return 0;
}

2.实验结果：

四、多机调度问题

1.问题描述：

利用贪心法设计算法求解如下问题：

要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。作业不能拆分成更小的子作业。

这个问题是一个NP完全问题，到目前为止还没有一个有效的解法。对于这一类问题，用贪心选择策略有时可以设计出较好的近似算法。

可以考虑以下的贪心策略：
（1）最长处理时间作业优先的贪心选择策略。
（2）最短处理时间作业优先的贪心选择策略。
（3）作业到达时间优先的贪心选择策略。

假设7个独立的作业由3台机器加工处理，各作业所需的处理时间为：{2，14，4，6，16，5，3}，写出以上算法求解此问题的结果。

代码实现：

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

struct node
{
    int time;
    int index;
}a[10];

bool cmp(node a,node b)
{
    return a.time>b.time;
}

int Min(int d[],int m)
{
    int mini=0;
    for(int i=1;i<m;i++)
    {
        if(d[i]<d[mini])
            mini=i;
    }
    return mini;
}

int main(int argc, char const *argv[])
{
    int n,m;
    int sum=0;
    int d[10];                  //机器运行时间。
    scanf("%d%d",&n,&m);        //n是作业数，m是机器数；
    for(int i=0;i<n;i++){
        scanf("%d",&a[i].time);
        a[i].index=i+1;
    }
    sort(a,a+n,cmp);
    if(n<=m)
        for(i=0;i<n;i++){
            printf("第%d个机器的作业号：%d，所需时间为：%d\n", i+1,a[i].index,a[i].time);
        }
    else
    {
        for(i=0;i<m;i++){
            printf("第%d个机器的作业号：%d，所需时间为：%d\n", i+1,a[i].index,a[i].time);
        }
        for(i=0;i<m;i++)
            d[i]=a[i].time;
        for(i=m;i<n;i++)
        {
            int flag=Min(d,m);
            printf("下一次为机器 %d 来处理作业  ,并且此次处理的作业为：%d\n", flag+1,a[i].index);
            d[flag]+=a[i].time;
        }
    }
    sum=d[0];
    for(i=0;i<m;i++)
        if(sum<d[i])
            sum=d[i];
    printf("所需要的最短时间为：%d\n", sum);
    return 0;
}

2.实验结果：