贪心法（——模板习题与总结）

摘要

　　本文主要讲解贪心法的基本思想和实现，怎么运用贪心法，着重讲解在编程竞赛中的一些典型应用。

　　什么是贪心法？

　　在编程竞赛中的典型应用有哪些？

　　例题解析

---

什么是贪心法？

　　贪心法本质上讲不是一种真正的算法，而是一种思想，就是解决问题的时候遵循着某种规则，不断贪心地选取当前最优策略，以达到结果最优的目的。比如硬币问题，给出1元、5元、10元、50元、100元的硬币各a、b、c、d、e个，问用这些硬币来支付A元，最少需要多少枚硬币？

　　很容易想到先用面额大的钱，依次往小即可。这就是贪心法的典型应用，只顾眼前的利益最大化，从而达到总体最优的效果。

在编程竞赛中的典型应用有哪些？

　　硬币问题，给出硬币的面额和个数，给出需要支付的钱数A，问至少、至多需要多少个硬币？比如HDU 3348 coins

　　区间问题，给出区间的个数和各个区间的起始和终止，问不能交叉的选取，最多能选取多少个区间？比如HDu 2037 今年暑假不AC

　　字典序最小问题，给出一个字符串，每次只能从头或者尾取一个字符组成另一个字符串，问字典序最小的字符串是哪个？比如POJ 3617 Best Cow Line

　　点覆盖问题，给出一个点能够覆盖的范围r和点数以及每个点的位置，问最少需要多少个点使得所有的点都被覆盖? 比如POJ 3069 Saruman's Army

　　哈夫曼编码问题，给出总的木板长度，需要分割的n个木块及长度，问将这根木板分割成n段的最小代价是多少，其中切割的代价等于被切木板的长度，比如将长度为13的木板切成8和5，所花费的代价是13。比如POJ 3253 Fence Repair

例题解析

　　HDU 3348 coins 问至少和至多需要多少个硬币，至少容易求，直接贪心先选取面额大的硬币即可，关键是怎么求最多需要多少硬币，有人想到还使用贪心，先选取面额小的硬币，这样是有漏洞的，优先将小的硬币选完之后，可能造成无法凑成A。

　　这里采用一种反向思维的解法，要想给出的硬币最多，那么手中剩下的硬币就得最少，这样就可以按照之前的方法解题了。只不过要凑的钱数变成了sum-A，计算出的是凑完手中钱最少需要多少个硬币，再用总的硬币数减去它，就可以的到答案了。参考代码如下：

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

const int v[5] = {1, 5, 10, 50, 100};

int main()
{
    int T;
    int A, a[5];
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d%d%d%d%d", &A, &a[0], &a[1], &a[2], &a[3], &a[4]);
        int mina = 0;
        int p1 = A;
        for(int i = 4; i >= 0; i--) {
            int t = min(p1 / v[i], a[i]);
            p1 -= t * v[i];
            mina += t;    
        }
        
        int maxa = 0;
        int sum = a[0] + 5 * a[1] + 10 * a[2] + 50 * a[3] + 100 * a[4];
        int p2 = sum - A;
        for(int i = 4; i >= 0; i--) {
            int t = min(p2 / v[i], a[i]);
            p2 -= t * v[i];
            maxa += t;    
        }
        maxa = a[0] + a[1] + a[2] + a[3] + a[4] - maxa;
        
        if(p1 != 0 || p2 != 0)
            printf("-1 -1
");
        else
            printf("%d %d
", mina, maxa);
    }
    return 0;
}

　　HDu 2037 今年暑假不AC 典型的区间调度问题，先将区间按照结束的早的优先级高的规则排序，然后每次选取结束时间最早的区间。用到了结构体排序，注意迭代的过程。

参考代码如下：

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

const int maxn = 110;
struct Node {
    int s, e;
}node[maxn];
bool cmp(Node a, Node b) {
    if(a.e == b.e)
        return a.s < b.s;
    return a.e < b.e;
}
int main()
{
    int n;
    while(scanf("%d", &n) == 1 && n) {
        for(int i = 0; i < n; i++) {
            scanf("%d%d", &node[i].s, &node[i].e);
        }        
        sort(node, node + n, cmp);
        
        int ans = 0, t = 0;
        for(int i = 0; i < n; i++) {
            if(t <= node[i].s){
                ans++;
                t = node[i].e;
            }
        }
        printf("%d
", ans);
    }
    return 0;
}

　　POJ 3617 Best Cow Line 很容易想到贪心的规则是每次从头或者尾选取较小的字符，不过需要注意的是如果两个字符相等，就需要比较后面的，换句换说就要比较一个串的正和反哪个字典序小，从而得出结论。实现较为巧妙，参考代码：

/*    
    给出一个字符串，问每次只能从头或者尾取一个字符，组成最小字典序的字符串
    每次比较从左起和从右起的字符串，比较出就输出 
*/
#include <cstdio>

const int maxn = 101000;
char s[maxn], rs[maxn];

int main() 
{
    int n, cnt = 0;
    while (scanf("%d", &n) != EOF) {
        for (int i = 0; i < n; i++) {
            scanf(" %c", &s[i]);
        }
        s[n] = '';
        //puts(s); 
        
        int a = 0, b = n - 1;
        while (a <= b) {
            bool left = false;
            //比较从左起和从右起的字符串
            for (int i = 0; a + i <= b; i++) {
                if (s[a + i] < s[b - i]) {
                    left = true;
                    break;
                } else if (s[a + i] > s[b - i]) {
                    left = false;
                    break;
                }
            }
            
            if (left) putchar(s[a++]);
            else putchar(s[b--]);
            cnt++;
            if(cnt == 80){
                printf("
");
                cnt = 0;
            }
        }
        printf("
");
    }
    return 0;
}

　　POJ 3069 Saruman's Army 典型的点覆盖问题，贪心的规则是保证能够覆盖最左边的点的情况下，尽量选取一个靠左点，然后跳过它能够覆盖的点，如此重复。代码如下：

/*
    给出一个灯能够照亮的范围r,给出n个点的位置，问至少需要安装多少个灯，使得每个点都在灯的范围内
    使用贪心法，找到一个最左边的位置，加上r,跳过能够覆盖的所有点，找到第一个不能覆盖的点，作为灯，
    然后再往右走r，跳过r内的点，计数，直到走完。 
*/
#include <cstdio>
#include <algorithm>
using namespace std;

const int maxn = 1010;

int a[maxn];
int main () 
{
    int r, n;
    while (scanf("%d%d", &r, &n) == 2 && r + n != -2) {
        for (int i = 0; i < n; i++) {
            scanf("%d", &a[i]);
        }
        sort (a, a + n);
        
        int i = 0, ans = 0;
        while (i < n) {
            int s = a[i++];
            while (i < n && s + r >= a[i]) 
                i++;
            int p = a[i - 1];
            while (i < n && p + r >= a[i]) 
                i++;
            
            ans++;
        }
        printf ("%d
", ans);
    }
    return 0;
} 

　　POJ 3253 Fence Repair 该题的解法作为计算法哈夫曼编码的算法而被熟知，使用了C++ STL 中的优先队列，实现起来非常简单。优先队列自定义优先级的两种方法如下：

#include <cstdio>
#include <queue>
using namespace std;
typedef long long LL;
priority_queue<int, vector<int>, greater<int> > pq;
int main()
{
    int n;
    while (scanf("%d", &n) != EOF) {
        while(!pq.empty())
            pq.pop();
        
        int tmp;
        for(int i = 0; i < n; i++) {
            scanf("%d", &tmp);
            pq.push(tmp);
        }
        
        LL ans = 0;
        while(pq.size() > 1) {
            int min1 = pq.top();
            pq.pop();
            int min2 = pq.top();
            pq.pop();
            
            ans += min1 + min2;
            pq.push(min1 + min2);
        }    
        printf("%lld
", ans);
    }
    return 0;
}

#include <cstdio>
#include <queue>
using namespace std;
typedef long long ll;
struct cmp {
    bool operator () (const int &a, const int &b) const {
        return a > b;
    }
};
priority_queue<int, vector<int>, cmp> pq;

int main ()
{
    int n;
    while (scanf("%d", &n) != EOF) {
        while (!pq.empty())
            pq.pop();
        for (int i = 0; i < n; i++) {
            int tmp;
            scanf("%d", &tmp);
            pq.push(tmp);
        }
        ll ans = 0;
        while(pq.size() > 1) {
            int min1 = pq.top();
            pq.pop();
            int min2 = pq.top();
            pq.pop();
            
            ans += min1 + min2;
            pq.push(min1 + min2);
        }
        printf("%lld
", ans);
    }
    return 0;
}

　　贪心法最大的特点就是和动态规划的相比只顾眼前的最优，熟悉动态规划的话，对贪心法会有更深层的理解，另外求解最短路中的prim算法和Dijkstra算法等都是运用了贪心法的思想。要学会并不难，关键是多动手实践。