贪心法

搜索算法和动态规划是在多种策略中选取最优解，贪心算法是遵循某种规则，不断地选取当前最优策略。 

一、硬币问题

有1元,5元,10元,50元,100元,500元的硬币各C1,C5,C10,C50,C100,C500枚。现在用这些硬币来支付A元，最少需要多少枚硬币。

策略是尽可能选取面额大的硬币

int main()
{
    int ans=0;
    int V[6]={1,5,10,50,100,500};
    int C[6];
    int A;
    cin>>A;
    for(int i=0;i<6;i++)
    {
        cin>>C[i];
    }
    for(int i=5;i>=0;i--)
    {
        int t=min(A/V[i],C[i]);
        A-=t*V[i];
        ans+=t;
    }
    cout<<ans<<endl;
    return 0;
}

二、区间问题

有n项工作。每项工作分别在si时间开始,在ti时间结束。对于每项工作，你都可以选择参与与否。如果选择了参与，那么自始至终都必须参与。此外，参与工作的时间段不能重复。

选择的策略是：在可选的工作中，每次都选取结束时间最早的工作。

#include<bits/stdc++.h>
using namespace std;
const int max_n=100000;
int n,s[max_n],t[max_n];
pair<int,int> itv[max_n];
int ans=0;
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>s[i]>>t[i];
        //对pair进行的是字典序比较
        //为了让结束时间早的工作排在前面
        itv[i].first=t[i];
        itv[i].second=s[i];
    }
    sort(itv,itv+n);

    //t是所选工作的结束时间
    int t=0;
    for(int i=0;i<n;i++)
    {
        if(t<itv[i].second)
        {
            ans++;
            t=itv[i].first;
        }
    }
    cout<<ans<<endl;
    return 0;
}

三、字典序最小问题

给定长度为n的字符串s，要构造一个长度为n的字符串t，起初，t是一个空串，随后反复进行如下操作。

1.从s的头部删除一个字符，加到t的尾部

2.从s的尾部删除一个字符，加到t的尾部

目标是要构造字典序尽可能小的字符串t。

选择的策略是：按照字典序比较s和将s反转后的s‘

如果s较小，就从s的开头取出一个文字，加到t的末尾

如果s’较小，就从s‘的开头取出一个文字，加到t的末尾。

#include<bits/stdc++.h>
using namespace std;
const int max_n=2000;
int n;
char s[max_n+1];
int main()
{
    cin>>n;
    cin>>s;
    int a=0,b=n-1;
    while(a<=b)
    {
        //将从左起和右起的字符串比较
        bool left=false;
        for(int i=0;i+a<=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--]);
    }
    putchar('
');
    return 0;
}

四、

直线上有n个点，点i的位置是xi。从这n个点中选择若干个，给他们加上标记。对每一个点，其距离为r以内的区域里必须有带有标记的点（自身也算）。至少要有多少点被加上标记。（poj3069）代码是求解大致流程，不完全符合题目。

策略是：首先选取最左边的点右侧距离最左点距离为R以内的最远点。标记后，从标记点+r的距离开始寻找“最左点”，重复操作。

#include<bits/stdc++.h>
using namespace std;
const int max_n=2000;
int x[max_n+1];
int n,r;
int main()
{
    cin>>n>>r;
    for(int i=0;i<n;i++)
    {
        cin>>x[i];
    }
    sort(x,x+n);
    int i=0,ans=0;
    while(i<n)
    {
        //s是没有被覆盖的最左边的点的位置
        int s=x[i++];
        //一直前进到距离s大于r的点
        while(i<n&&x[i]<=s+r) i++;
        int p=x[i-1];
        //一直前进道距离p大于r的店
        while(i<n&&x[i]<=p+r) i++;
        ans++;
    }
    cout<<ans<<endl;
    return 0;
}

五、

农夫约翰为了修理栅栏，要将一块很长的木板切割成n块。准备切成的木板的长度为l1,l2,...,ln。未切割前木板的长度恰好为切割后木板长度的总和。每次切断木板时，需要的开销为这块木板的长度。求按要求切完的最小开销。只说明了大概意思。

分析如下：

切割的方法可以用二叉树来描述。但是我实在懒。所以就简单表述一下这颗树。木板起始长度为15.

                             15

                       7             8

                  3        4    5      3

                                       1     2

我猜应该能勉强看出这是一个二叉树。。。然后我们发现开销的合计为 ： 所有叶子节点的权值*叶子节点的深度的总和。

即3*2+4*2+5*2+1*3+2*3=33。

此时的最佳切割方法首先应该有如下性质：最短的板与次短的板的节点应当是兄弟节点（对于最优解来说，最短的板应该是深度最大的叶子节点之一，所以与这个叶子节点同一深度的兄弟节点一定存在，由于同样是最深的叶子节点，所以应该对应于次短的板）。

#include<bits/stdc++.h>
using namespace std;
const int max_n=20000;
int l[max_n+1];
int n;
int ans=0;
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>l[i];
    }

    //计算到木板为1块为止
    while(n>1)
    {
        //求出最短的板mii1和次短的板mii2
        int mii1=0,mii2=1;
        if(l[mii1]>l[mii2]) swap(mii1,mii2);
        for(int i=2;i<n;i++)
        {
            if(l[i]<l[mii1])
            {
                mii2=mii1;
                mii1=i;
            }
            else if(l[i]<l[mii2])
            {
                mii2=i;
            }
        }

        //合并两板
        int combine=l[mii1]+l[mii2];
        ans+=combine;

        //mii1的位置放合并板，mii2的位置放最后一块板
        if(mii1==n-1) swap(mii1,mii2);
        l[mii1]=combine;
        l[mii2]=l[n-1];
        n--;
    }
    cout<<ans<<endl;
    return 0;
}

然后可以联想到霍夫曼编码（当码字长度为整数情况时最优的编码方案）。频度较高的字母对应较短的01序列，频度较低的字母对应较长的01序列。将木板换成字符，长度换成频度可以类比。