贪心算法例题整理

贪心算法问题
2018年09月15日 15:44:37 Dyson~ 阅读数：652
一、概念

1. 贪心法（Greedy Algorithm）定义

求解最优化问题的算法通常需要经过一系列的步骤，在每个步骤都面临多种选择；

贪心法就是这样的算法：它在每个决策点作出在当时看来最佳的选择，即总是遵循某种规则，做出局部最优的选择，以推导出全局最优解（局部最优解->全局最优解）

2. 对贪心法的深入理解

   （1）原理：一种启发式策略，在每个决策点作出在当时看来最佳的选择

    （2）求解最优化问题的两个关键要素：贪心选择性质+最优子结构
        
             ①贪心选择性质：进行选择时，直接做出在当前问题中看来最优的选择，而不必考虑子问题的解；
        
             ②最优子结构：如果一个问题的最优解包含其子问题的最优解，则称此问题具有最优子结构性质
        
            （3）解题关键：贪心策略的选择
        
            贪心算法不是对所有问题都能得到整体最优解的，因此选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。
        
            （4）一般步骤：
        
            ①建立数学模型来描述最优化问题；
        
            ②把求解的最优化问题转化为这样的形式：对其做出一次选择后，只剩下一个子问题需要求解；
        
            ③证明做出贪心选择后：
        
                    1°原问题总是存在全局最优解，即贪心选择始终安全；
        
                    2°剩余子问题的局部最优解与贪心选择组合，即可得到原问题的全局最优解。
        
                    并完成2°
   

3. 贪心法与动态规划

    最优解问题大部分都可以拆分成一个个的子问题，把解空间的遍历视作对子问题树的遍历，则以某种形式对树整个的遍历一遍就可以求出最优解，大部分情况下这是不可行的。贪心算法和动态规划本质上是对子问题树的一种修剪，两种算法要求问题都具有的一个性质就是子问题最优性(组成最优解的每一个子问题的解，对于这个子问题本身肯定也是最优的)。动态规划方法代表了这一类问题的一般解法，我们自底向上构造子问题的解，对每一个子树的根，求出下面每一个叶子的值，并且以其中的最优值作为自身的值，其它的值舍弃。而贪心算法是动态规划方法的一个特例，可以证明每一个子树的根的值不取决于下面叶子的值，而只取决于当前问题的状况。换句话说，不需要知道一个节点所有子树的情况，就可以求出这个节点的值。由于贪心算法的这个特性，它对解空间树的遍历不需要自底向上，而只需要自根开始，选择最优的路，一直走到底就可以了。
   

二、典型问题分析

1. （引例）矩阵选数问题

在N行M列的正整数矩阵中，要求从每行中选出1个数，使得选出的总共N个数的和最大。（1<=N, M<=100，结果在int范围内）

【分析】要使总和最大，则每个数要尽可能大，自然应该选每行中最大的那个数。

    局部最优解：每行中的最大数；全局最优解：N个数和的最大值。

#include <stdio.h>  
#define maxn 105  
int N,M;  
int maxnum;   //maxnum记录每行中的最大值  
int sum=0;    //sum记录每行中的最大值之和   
int a[maxn][maxn];  
int main()  
{  
    int i,j;  
    scanf("%d %d",&N,&M);  
    for(i=0;i<N;i++)  
        for(j=0;j<M;j++)  
            scanf("%d",&a[i][j]);  
    for(i=0;i<N;i++)  
    {  
        maxnum=0;      
        for(j=0;j<M;j++)   //循环更新每行的最大值   
        {  
            if(a[i][j]>maxnum)  
                maxnum=a[i][j];  
        }  
        sum+=maxnum;   
    }  
    printf("%d\n",sum);  
    return 0;  
} 

2. 钱币找零问题

有1元、5元、10元、50元、100元、500元的硬币各C1, C5, C10, C50, C100, C500枚。现在要用这些硬币来支付A元，最少需要多少枚硬币？若有解，输出最少硬币数；否则输出“-1”（0<=C1, C5, C10, C50, C100, C500<=109，0<=A<=109）

【分析】凭直觉，我们可以优先使用面值大的硬币（在这里是500、100、50、10、5、1）

#include <iostream>  
using namespace std;  
int A;   
int ans=0;      //所需硬币总数  
int ret[6]={0}; //所需每种硬币的数量   
int moneycnt[6];//现有6种硬币的数量   
int moneyval[6]={1,5,10,50,100,500};//每种硬币的面值   
int main()  
{  
    int i;  
    int temp;  
    cin>>A;  
    for(i=0;i<6;i++)  
        cin>>moneycnt[i];  
    //贪心策略：优先选择面值大的硬币   
    for(i=5;i>=0;i--)  
    {  
        //temp记录使用硬币i的枚数，注意不能超过moneycnt[i]   
        temp=min(A/moneyval[i],moneycnt[i]);   
        //剩余支付金额   
        A-=(temp*moneyval[i]);  
        //使用硬币i的枚数+temp   
        ret[i]+=temp;  
        //已使用的硬币数+temp   
        ans+=temp;             
    }   
    //A>0表示无法用现有硬币支付A元，故输出-1   
    if(A>0)  
        cout<<"-1"<<endl;  
    //其它情况：可完成支付   
    else  
    {  
        //最少硬币数   
        cout<<ans<<endl;  
        //每种硬币需要的数量   
        for(i=0;i<6;i++)  
            cout<<moneyval[i]<<"元:"<<ret[i]<<endl;  
    }  
    return 0;  
}  

3. “背包”相关问题

    （Ⅰ）最优装载问题
   

有n个物体，第i个物体的重量为wi（wi为正整数）。选择尽量多的物体，使得总重量不超过C。

【分析】由于只关心选择的物品的最大数量（而不是最大重量，最大重量需要考虑DP），所以装重的物体没有装轻的物体划算。这里只需对n个物体按重量递增排序，依次选择每个物体直到装不下为止。

这是一种典型的贪心算法，它只顾眼前，却能得到最优解。

#include <iostream>  
#include <cstdio>  
#include <algorithm>  
using namespace std;  
const int maxn=1005;  
int n,C;     //n个物体 最大载重量C   
int w[maxn]; //第i种物品的重量   
int main()  
{  
    int i;  
    int ans=0,sum=0;  //ans-选择的物品数 sum-当前物品总装量   
    scanf("%d",&n);  
    for(i=0;i<n;i++)  
        scanf("%d",&w[i]);  
    scanf("%d",&C);  
    //按物品重量递增排序   
    sort(w,w+n);  
    for(i=0;i<n;i+&