贪心算法

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

#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
	int n;
	float waittime=0;
	float mintime;
	cin>>n;
	int a[100];
	for(int i=1;i<=n;i++)
		cin>>a[i];//每位顾客的服务时间
	sort(a+1,a+n+1);
	for(int j=2;j<=n;j++)
	{
		waittime=waittime+ a[j-1]+a[j];
	}
	mintime=waittime/n;
	cout<<"最小平均等待时间为："<<mintime<<endl;	
return 0;
}

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

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
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;
}
int main()
{
	int n,s,x;
	double sum;
	vector<int>a;
	cin>>n>>s;
	for(int i=0;i<n;i++)
	{
		cin>>x;
		a.push_back(x);
	}
	sum=greedy(a,s);
	cout<<sum<<endl;
	return 0;
}

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

#include<stdio.h>
int main()
{
    int j,k,n,count;
    int index=0,sum=0;
    int i=2;
    int a[100]={0};
    a[2]=2;
    scanf("%d",&n);
    while(n-sum>=i) { //从2开始，对n进行分解 
        sum+=i;
        a[i]=i;
        i++;
        index++;
    } 
    int p=(n-sum)/index; //整体全部累加 
    int q=(n-sum)%index; //只从后往前，加最后剩余的 
    for(j=i-1;j>=2;j--) {
        a[j]+=p;
    }
    for(k=i-1;k>i-1-q;k--) {
        a[k]++;
    }
	count=a[2];
    for(j=3;j<index+2;j++) {
		count=count*a[j];   
    } 
	 printf("%d  \n",count);
}

4. 多机调度问题
   利用贪心法设计算法求解如下问题：
   要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。作业不能拆分成更小的子作业。
   这个问题是一个NP完全问题，到目前为止还没有一个有效的解法。对于这一类问题，用贪心选择策略有时可以设计出较好的近似算法。
   假设7个独立的作业由3台机器加工处理，各作业所需的处理时间为：{2，14，4，6，16，5，3}，写出以上算法求解此问题的结果。
   可以考虑以下的贪心策略：
   （1） 最长处理时间作业优先的贪心选择策略。

#include <iostream>
#include <algorithm>
using namespace std;
 

//找到当前空闲的机器
int FindIndexOfMin(int b[],int m)
{
    int t=0,minc=b[0];
    for(int i=1;i<m;i++)
    {
        if(minc>b[i])
        {
            t=i;
            minc=b[i];
        }
    }
    return t;
}
 
bool cmp(int a,int b)
{
	return a>b;
}
void Greedy(int a[],int b[],int n,int m)
{
    if(n<=m)
    {
        cout<<"为每个作业分配一台机器."<<endl;
        return;
    }
    sort(a,a+n,cmp);//把作业按照处理时间从小到大排序
    int i=0,j=0;
    while(j<n)
    {
        if(i<m)//先按序分配给机器
        {
            b[i]=a[j];
            i++;j++;
        }
        else//每次找到空闲的机器分配作业
        {
            int index=FindIndexOfMin(b,m);
            b[index]+=a[j];
            j++;
        }
    }
}
 
int main()
{
    int a[]={2,14,4,16,6,5,3},
        b[]={0,0,0};
    Greedy(a,b,7,3);
	int sum=0;
	cout<<"最长时间优先：";
    for(int i=0;i<3;i++)
		cout<<b[i]<<" ";
	cout<<endl;
	for(int k=0;k<3;k++)
		sum=sum+b[k];
    cout<<"最长时间优先花费时间为："<<sum<<endl;
	return 0;
}

（2） 最短处理时间作业优先的贪心选择策略。

#include <iostream>
#include <algorithm>
using namespace std;
 

//找到当前空闲的机器
int FindIndexOfMin(int b[],int m)
{
    int t=0,minc=b[0];
    for(int i=1;i<m;i++)
    {
        if(minc>b[i])
        {
            t=i;
            minc=b[i];
        }
    }
    return t;
}
 
void Greedy(int a[],int b[],int n,int m)
{
    if(n<=m)
    {
        cout<<"为每个作业分配一台机器."<<endl;
        return;
    }
    sort(a,a+n);//把作业按照处理时间从小到大排序
    int i=0,j=0;
    while(j<n)
    {
        if(i<m)//先按序分配给机器
        {
            b[i]=a[j];
            i++;j++;
        }
        else//每次找到空闲的机器分配作业
        {
            int index=FindIndexOfMin(b,m);
            b[index]+=a[j];
            j++;
        }
    }
}
 
int main()
{
    int a[]={2,14,4,16,6,5,3},
        b[]={0,0,0};
    Greedy(a,b,7,3);
	int sum=0;
    for(int i=0;i<3;i++)
	//	cout<<b[i]<<" ";
		sum=sum+b[i];
    cout<<"最短处理作业优先时间为："<<sum<<endl;
	return 0;
}

（3） 作业到达时间优先的贪心选择策略。

#include <iostream>
#include <algorithm>
using namespace std;
 

//找到当前空闲的机器
int FindIndexOfMin(int b[],int m)
{
    int t=0,minc=b[0];
    for(int i=1;i<m;i++)
    {
        if(minc>b[i])
        {
            t=i;
            minc=b[i];
        }
    }
    return t;
}
 
void Greedy(int a[],int b[],int n,int m)
{
    if(n<=m)
    {
        cout<<"为每个作业分配一台机器."<<endl;
        return;
    }
    //sort(a,a+n);//把作业按照处理时间从小到大排序
    int i=0,j=0;
    while(j<n)
    {
        if(i<m)//先按序分配给机器
        {
            b[i]=a[j];
            i++;j++;
        }
        else//每次找到空闲的机器分配作业
        {
            int index=FindIndexOfMin(b,m);
            b[index]+=a[j];
            j++;
        }
    }
}
 
int main()
{
    int a[]={2,14,4,16,6,5,3},
        b[]={0,0,0};
    Greedy(a,b,7,3);
	int sum=0;
	cout<<"作业到达时间优先：";
    for(int i=0;i<3;i++)
		cout<<b[i]<<" ";
	cout<<endl;
	for(int k=0;k<3;k++)
		sum=sum+b[k];
    cout<<"最短处理作业优先时间为："<<sum<<endl;
	return 0;
}