【基础算法】(07)五大常用算法之三:贪心算法

【基础算法】(07)五大常用算法之三:贪心算法

Auther: Thomas Shen
E-mail: Thomas.shen3904@qq.com
Date: 2017/10/23
All Copyrights reserved !

1. 简述:

本系列介绍了五大常用算法,其中本文是第三篇,介绍了 ‘贪心算法’ 的细节内容。

所谓贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解。

贪心算法没有固定的算法框架,算法设计的关键是贪心策略的选择。必须注意的是,贪心算法不是对所有问题都能得到整体最优解,选择的贪心策略必须具备无后效性,即某个状态以后的过程不会影响以前的状态,只与当前状态有关。所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。

2. 算法原理:

2.1 基本思路:

1.建立数学模型来描述问题。
2.把求解的问题分成若干个子问题。
3.对每一子问题求解,得到子问题的局部最优解。
4.把子问题的解局部最优解合成原来解问题的一个解。

2.2 适用问题:

贪心策略适用的前提是:局部最优策略能导致产生全局最优解。

实际上,贪心算法适用的情况很少。一般,对一个问题分析是否适用于贪心算法,可以先选择该问题下的几个实际数据进行分析,就可做出判断。

因为用贪心算法只能通过解局部最优解的策略来达到全局最优解,因此,一定要注意判断问题是否适合采用贪心算法策略,找到的解是否一定是问题的最优解。

3. 实现框架:

    从问题的某一初始解出发;
    while (能朝给定总目标前进一步)
    { 利用可行的决策,求出可行解的一个解元素; }
    由所有解元素组合成问题的一个可行解;

4. 应用案例:

4.1 案例一:

钱币找零问题:

这个问题在我们的日常生活中就更加普遍了。假设1元、2元、5元、10元、20元、50元、100元的纸币分别有c0, c1, c2, c3, c4, c5, c6张。现在要用这些钱来支付K元,至少要用多少张纸币?用贪心算法的思想,很显然,每一步尽可能用面值大的纸币即可。在日常生活中我们自然而然也是这么做的。在程序中已经事先将Value按照从小到大的顺序排好。

#include<iostream> 
#include<algorithm> 
using namespace std;  
const int N=7;   
int Count[N]={3,0,2,1,0,3,5};  
int Value[N]={1,2,5,10,20,50,100};  

int solve(int money)   
{  
    int num=0;  
    for(int i=N-1;i>=0;i--)   
    {  
        int c=min(money/Value[i],Count[i]);  
        money=money-c*Value[i];  
        num+=c;  
    }  
    if(money>0) num=-1;  
    return num;  
}  

int main()   
{  
    int money;  
    cin>>money;  
    int res=solve(money);  
    if(res!=-1) cout<<res<<endl;  
    else cout<<"NO"<<endl;  
}  
4.2 案例二:

多机调度问题:

n个作业组成的作业集,可由m台相同机器加工处理。要求给出一种作业调度方案,使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。作业不能拆分成更小的子作业;每个作业均可在任何一台机器上加工处理。这个问题是NP完全问题,还没有有效的解法(求最优解),但是可以用贪心选择策略设计出较好的近似算法(求次优解)。当n<=m时,只要将作业时间区间分配给作业即可;当n>m时,首先将n个作业从大到小排序,然后依此顺序将作业分配给空闲的处理机。也就是说从剩下的作业中,选择需要处理时间最长的,然后依次选择处理时间次长的,直到所有的作业全部处理完毕,或者机器不能再处理其他作业为止。如果我们每次是将需要处理时间最短的作业分配给空闲的机器,那么可能就会出现其它所有作业都处理完了只剩所需时间最长的作业在处理的情况,这样势必效率较低。在下面的代码中没有讨论n和m的大小关系,把这两种情况合二为一了。

#include<iostream> 
#include<algorithm> 
using namespace std;    
int speed[10010];    
int mintime[110];    

bool cmp( const int &x,const int &y)    
{    
    return x>y;    
}    

int main()    
{    
    int n,m;           
    memset(speed,0,sizeof(speed));    
    memset(mintime,0,sizeof(mintime));    
    cin>>n>>m;    
    for(int i=0;i<n;++i) cin>>speed[i];    
    sort(speed,speed+n,cmp);    
    for(int i=0;i<n;++i)     
    {   
        *min_element(mintime,mintime+m)+=speed[i];     
    }     
    cout<<*max_element(mintime,mintime+m)<<endl;   
}  
4.3 案例三:

小船过河问题:

POJ1700是一道经典的贪心算法例题。题目大意是只有一艘船,能乘2人,船的运行速度为2人中较慢一人的速度,过去后还需一个人把船划回来,问把n个人运到对岸,最少需要多久。先将所有人过河所需的时间按照升序排序,我们考虑把单独过河所需要时间最多的两个旅行者送到对岸去,有两种方式:

  1. 最快的和次快的过河,然后最快的将船划回来;次慢的和最慢的过河,然后次快的将船划回来,所需时间为:t[0]+2*t[1]+t[n-1];
  2. 最快的和最慢的过河,然后最快的将船划回来,最快的和次慢的过河,然后最快的将船划回来,所需时间为:2*t[0]+t[n-2]+t[n-1]。
    算一下就知道,除此之外的其它情况用的时间一定更多。每次都运送耗时最长的两人而不影响其它人,问题具有贪心子结构的性质。
#include<iostream> 
#include<algorithm> 
using namespace std;  

int main()  
{  
    int a[1000],t,n,sum;  
    scanf("%d",&t);  
    while(t--)  
    {  
        scanf("%d",&n);  
        sum=0;  
        for(int i=0;i<n;i++) scanf("%d",&a[i]);  
        while(n>3)  
        {  
            sum=min(sum+a[1]+a[0]+a[n-1]+a[1],sum+a[n-1]+a[0]+a[n-2]+a[0]);  
            n-=2;  
        }  
        if(n==3) sum+=a[0]+a[1]+a[2];  
        else if(n==2) sum+=a[1];  
        else sum+=a[0];  
        printf("%d\n",sum);  
    }  
}  
4.4 案例四:

区间覆盖问题:

POJ1328是一道经典的贪心算法例题。题目大意是假设海岸线是一条无限延伸的直线。陆地在海岸线的一侧,而海洋在另一侧。每一个小的岛屿是海洋上的一个点。雷达坐落于海岸线上,只能覆盖d距离,所以如果小岛能够被覆盖到的话,它们之间的距离最多为d。题目要求计算出能够覆盖给出的所有岛屿的最少雷达数目。对于每个小岛,我们可以计算出一个雷达所在位置的区间。

《【基础算法】(07)五大常用算法之三:贪心算法》

问题转化为如何用尽可能少的点覆盖这些区间。先将所有区间按照左端点大小排序,初始时需要一个点。如果两个区间相交而不重合,我们什么都不需要做;如果一个区间完全包含于另外一个区间,我们需要更新区间的右端点;如果两个区间不相交,我们需要增加点并更新右端点。

#include<cmath> 
#include<iostream> 
#include<algorithm> 
using namespace std;  
struct Point  
{  
    double x;  
    double y;  
}point[1000];  

int cmp(const void *a, const void *b)  
{  
    return (*(Point *)a).x>(*(Point *)b).x?1:-1;  
}  

int main()  
{  
    int n,d;  
    int num=1;  
    while(cin>>n>>d)  
    {  
        int counting=1;  
        if(n==0&&d==0) break;  
        for(int i=0;i<n;i++)  
        {  
            int x,y;  
            cin>>x>>y;  
            if(y>d)  
            {  
                counting=-1;  
            }  
            double t=sqrt(d*d-y*y);  
            //转化为最少区间的问题 
            point[i].x=x-t;  
            //区间左端点 
            point[i].y=x+t;  
            //区间右端点 
        }  
        if(counting!=-1)  
        {  
            qsort(point,n,sizeof(point[0]),cmp);  
            //按区间左端点排序 
            double s=point[0].y;  
            //区间右端点 
            for(int i=1;i<n;i++)  
            {  
                if(point[i].x>s)  
                //如果两个区间没有重合,增加雷达数目并更新右端点 
                {  
                    counting++;  
                    s=point[i].y;   
                }  
                else if(point[i].y<s)  
                //如果第二个区间被完全包含于第一个区间,更新右端点 
                {  
                    s=point[i].y;  
                }  
            }  
        }  
        cout<<"Case "<<num<<':'<<' '<<counting<<endl;  
        num++;   
    }  
}     
4.5 案例五:

销售比赛:

假设有偶数天,要求每天必须买一件物品或者卖一件物品,只能选择一种操作并且不能不选,开始手上没有这种物品。现在给你每天的物品价格表,要求计算最大收益。首先要明白,第一天必须买,最后一天必须卖,并且最后手上没有物品。那么除了第一天和最后一天之外我们每次取两天,小的买大的卖,并且把卖的价格放进一个最小堆。如果买的价格比堆顶还大,就交换。这样我们保证了卖的价格总是大于买的价格,一定能取得最大收益。

#include<queue> 
#include<vector> 
#include<cstdio> 
#include<cstdlib> 
#include<cstring> 
#include<iostream> 
#include<algorithm> 
using namespace std;  
long long int price[100010],t,n,res;  

int main()  
{  
    ios::sync_with_stdio(false);  
    cin>>t;  
    while(t--)  
    {  
        cin>>n;  
        priority_queue<long long int, vector<long long int>, greater<long long int> > q;  
        res=0;  
        for(int i=1;i<=n;i++)  
        {  
            cin>>price[i];  
        }  
        res-=price[1];  
        res+=price[n];  
        for(int i=2;i<=n-1;i=i+2)  
        {  
            long long int buy=min(price[i],price[i+1]);  
            long long int sell=max(price[i],price[i+1]);  
            if(!q.empty())  
            {  
                if(buy>q.top())  
                {  
                    res=res-2*q.top()+buy+sell;  
                    q.pop();  
                    q.push(buy);  
                    q.push(sell);  
                }  
                else  
                {  
                    res=res-buy+sell;  
                    q.push(sell);  
                }  
            }  
            else  
            {  
                res=res-buy+sell;  
                q.push(sell);  
            }  
        }       
        cout<<res<<endl;  
    }  
}  

References. :

    原文作者:五大常用算法
    原文地址: https://blog.csdn.net/u011384489/article/details/78307051
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞