贪心算法1

1、学前须知
这是一种求最优解的方法。它是按照某种最优策略，将复杂问题层层分解成子问题（每次一般只有一个），并由子问题的最优解“回溯”出整个问题的最优解。贪心算法不是从整体上考虑问题，它所做出的选择只是在某种意义上的局部最优解，而由问题自身的特性决定了该题运用贪心算法可以得到最优解。如果一个问题可以同时用几种方法解决，贪心算法应该是其中最好的解决方法

2、在利用贪心策略解决问题时，我们应该提前解决两个问题
（1）第一个问题是该题是否适合于用贪心策略求解；
（2）第二个我们要解决的问题是我们应该如何选择贪心标准，以得到问题的最优/较优解，即制定贪心策略。

3、光说不练假把式，下面我们来用几道例题来学习贪心算法

1. 最优装载问题
① 问题描述：有一批集装箱要装上一艘载重量为c的轮船，其中集装箱i的重量为wi。最优装载问题要求确定在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船。
②贪心策略：先将轻的箱子放在船上
③代码实现

#include <iostream>
#include <algorithm>//使用sort前需要加上algorithm的函数头
using namespace std;
struct load//用结构体将index与w绑在一起
{
    int index;//集装箱的编号
    int w;//集装箱的重量
}box[100];
bool cmp(load a,load b)//因为需要按照重量从低到高排列，定义比较函数，而且排序函数必须为bool类型，返回值为true则不变，返回值为false则改变
{
    if(a.w<b.w)
    return true;
    else
    return false;
}
int main()
{
    int c,n;
    cin>>c>>n;
    for(int i=0;i<n;i++)//输入每个集装箱的重量与编号
    {
        cin>>box[i].w;
        box[i].index=i+1;
    }
    stable_sort(box,box+n,cmp);//stable_sort比sort更加稳定
    if(box[0].w>c) cout<<"No answer"<<endl;
    if(box[0].w=c) cout<<1<<endl;
    if(box[0].w<c)
    {
        int i;
        for(int i=0;i<n&&box[i].w<=c;i++)
        {
            c-=box[i].w;
        }
        cout<<i+1<<endl;
    }
}

2.背包问题
①问题描述
给定一个载重量为M的背包，考虑n个物品，其中第i个物品的重量 ，价值wi （1≤i≤n），要求把物品装满背包，且使背包内的物品价值最大。
我们可以怎么贪？
1.多装物品，每次挑轻的物品；
2.选价值大的物品；
3.按性价比选择；
②贪心策略、
很明显，按性价比选择为本题的最优解法
③代码实现

#include <iostream>
#include <algorithm>
using namespace std;
struct bag
{
    int w;//重量
    int v;//价值
    double c;//性价比
}a[1001];
bool cmp (bag a,bag b)//比较函数来比较a.c的大小并在sort中排序
{
    if(a.c>b.c) return true;
    else
    return false;
}
double  knapsack(int n,bag a[],double c)//n为物体个数，c为最大承重量
{
    double cleft=c;//剩余载重
    int i=0;
    double b=0;//可得利益
    while(i<n&&a[i].w<cleft)
    {
        cleft-=a[i].w;
        b+=a[i].v;
        i++;
    }
    if(i<n)
    b+=a[i].c*cleft;//无法放入真个物体时拆开放入
    return b;

}
int main()
{
    double M;//最大载重量
    cin>>M;
    int n=0;
    while(cin>>a[n].w>>a[n].v)
    {
        a[n].c=a[n].v*1.0/a[n].w;
    }
    stable_sort(a,a+n,cmp);
    cout<<knapsack(n,a,M)<<endl;
    return 0;
}

3.货币找零
①问题描述：
假设1元、2元、5元、10元、20元、50元、100元的纸币分别有c0, c1, c2, c3, c4, c5, c6张。现在要用这些钱来支付K元，至少要用多少张纸币？
②贪心策略：
每一步尽可能用面值大的纸币
③代码实现

#include <iostream>

using namespace std;
const int N=7;
int Count[N]={3,1,7,5,2,7};//此命名不能为count而应该为Count，因为count本身是关键词
int value[N]={100,50,20,10,5,1};
void solve(int money)//函数如果是为了解决问题的过程，一般命名为solve
{   int ans=0;//当前所用货币的总张数
    for(int i=0;i<N;i++)
    {
        int c=min(Count[i],money/value[i]);//c为本次使用货币的张数
        money-=c*value[i];
        if(c!=0)//当c不为零时将c累加如总张数ans中
        {
            ans+=c;
        }
    }
    if(money>0) cout<<"不能找零"<<endl;//最后money>0时表示所有钱用完后依旧还没完成找零
    else cout<<ans<<endl;
}
int main()
{
    int money;
    cin>>money;
    solve(money);
}

4.区间调度问题
①问题描述：
有n项工作，每项工作分别在Si开始，Ti结束。例如S={1,2,4,6,8}，T={3,5,7,8,10}。对每项工作，你都可以选择与否，若选择参加，则必须至始至终参加全程参与，且参与工作的时间段不能有重叠。（如下图）你最多能选择几项工作。

②贪心策略：
在可选工作中，每次都选取结束时间最早的
③代码实现

#include <iostream>
#include <algorithm>
struct Time
{
   int S;
   int T;
};
bool cmp(Time a,Time b)
{
    return a.T<b.T;
}

using namespace std;
int solve()
{
    int n;
    cin>>n;
    Time Class[n];
    for(int i=0;i<n;i++)
    {
        cin>>Class[i].S;
    }
    for(int i=0;i<n;i++)
    {
        cin>>Class[i].T;
    }
    sort(Class,Class+n,cmp);
    int count=0;
    int t=0;//最后所选工作的截止日期
    for(int i=0;i<n;i++)
    {
        if(t<Class[i].S)
        {
            t=Class[i].T;
            count++;
        }
    }
    return count;
}


int main()
{
    int k=solve();
    cout<<k<<endl;
    return 0;
}

5.字典序最小问题
①问题描述：
给定长度为N的字符串S，要构造一个长度为N字符串T。T是一个空串，反复执行下列任意操作：
1：从S的头部删除一个字符，加到T的尾部；
2：从S的尾部删除一个字符，加到T的尾部；
目标是要构造字典序尽可能小的字符串T。
注：字典序是指从前到后比较两个字符串的大小的方法。首先比较第1个字符，如果不同则第1个字符较小的字符串更小，如果相同则继续比较第2个字符…反复继续，来比较整个字符串的大小。
②贪心策略：
不断取S的开头和末尾中字符序较小的那个字符放到T的末尾
③代码实现：

#include <iostream>

using namespace std;

int main()
{
    int n;
    cin>>n;
    char t[n];
    for(int i=0;i<n;i++)
    {
        cin>>t[n];
    }
    int a=0,b=n-1;
    while(a<=b)
    {
        bool left=false;
        for(int i=0;a+i<b;i++)//当头与尾相等时可以继续判断
        {
            if(t[a+i]<t[b-i])\
            {
                left=true;
                break;
            }
            else if(t[a+i]<t[b-i])
            {
                left=false;//这行代码可有可无
                break;
            }
        }
        if(left) cout<<t[a++];
        else cout<<t[b--];
    }
    return 0;
}