贪心总结

问题 A: 【贪心】删数问题

题目：
输入一个高精度的正整数n（≤240位），去掉其中任意s个数字后，剩下的数字按原左右次序组成一个新的正整数。编程对给定的n和s，寻找一种方案，使得剩下的数字组成的新数最小。
输入 第1行：一个正整数n； 第2行：s（s<n的位数).
输出：最后剩下的最小数。

思路：当a[i]>a[i+1]时删除a[i],否则删除最后一个数，因为同样的位数是从前往后比较的，而若该位数 i 比后面的小，删除第i位，不如删除第i+1位
例如： 123546 1 删除5，而不是3，也不是6；
12346
12546
12354 前者比较小

简洁的代码：

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
    string s; cin>>s;
    int k; cin>>k;
    while(k)
    {
        int i;
        for(i=0; i<s.size()-1; i++) if(s[i]>s[i+1])  break;
        s.erase(i,1);
        k--;
    }
    int i=0;
    for(;s[i]=='0'&&i<s.size()-1;i++); s=s.substr(i,s.size()-i);
    cout<<s<<endl;
    return 0;
}

---

问题 C: 【贪心】砍树

题目：

树紧密地排成一条直线，并且用l～N编号标识，每一棵树都有自己的高度Hi(1≤Hi≤10000)。
FJ想用一种烈性炸药来摧毁这些树，这种烈性炸药除了能摧毁安装了炸药的那棵树以外还能传递压倒两边矮于这一棵树的所有邻近树，直到遇到一棵不低于这一棵树的树为止。
例如：一排树的高度如下：1 2 5 4 3 3 6 6 2，如果FJ在第三棵树上装炸药（高度为5），那么第二棵树也同样给压倒（高度为2<5），第一棵树也同样倒下（高度为1<2），再来看另一边第四棵树（高度为4<5）和第五棵树（高度为3<4）同样也给压倒。剩下的状态为：* * * * * 3 6 6 2，接下来在第7和第8棵树上安装炸药就可以把剩下的树毁掉。
请你帮助Fj利用最少的炸药把这些树毁掉。
输入
第1行：一个整数N(1≤N≤50000)；
第2～N+1行：包含各棵树的高度Hi。
输出
每一行为一个整数，代表安装炸药的树的编号，按照升序输出。

#include <iostream>

using namespace std;
int a[50005];
int main()
{
    int n;cin>>n;
    for(int i=1;i<=n;i++)  cin>>a[i];
    int flag=0;
    for(int i=1;i<n;i++)
    {
        flag=0;
        if(a[i+1]<=a[i])
        {
            flag=1;
            cout<<i<<endl;
            int j;
            for(j=i;j<n;j++)
            {
                if(a[j]<=a[j+1]) break;
            }
            i=j;
            if(j==n-1) cout<<n<<endl;///最后一个要特判
        }
    }
    if(!flag) cout<<n<<endl;///若单调递增则输出n
    return 0;
}
/*
10
1 2 5 2 3 4 2 1 1 5
5
1 2 3 5 4
*/

---

问题 E: 【贪心】纪念品分组

题目：
元旦快到了，校学生会让乐乐负责新年晚会的纪念品发放工作。为使得参加晚会的同学所获得 的纪念品价值相对均衡，他要把购来的纪念品根据价格进行分组，但每组最多只能包括两件纪念品， 并且每组纪念品的价格之和不能超过一个给定的整数。为了保证在尽量短的时间内发完所有纪念品，乐乐希望分组的数目最少。
你的任务是写一个程序，找出所有分组方案中分组数最少的一种，输出最少的分组数目。
输入
输入包含n+2行:
第1行包括一个整数w，为每组纪念品价格之和的上限； 第2行为一个整数n，表示购来的纪念品的总件数G
第3-n+2行每行包含一个正整数Pi (5 <= Pi <= w)w表示所对应纪念品的价格。
100%的数据满足: 1 <= n <= 30000， 80 <= w <= 200
输出
仅1行，包含一个整数， 即最少的分组数目

思路：最简单的贪心策略，一开始想复杂了

#include <iostream>
#include <algorithm>
using namespace std;
int visit[205];
int a[30005];
int main()
{
    int n,w;cin>>w>>n;
    for(int i=1;i<=n;i++) cin>>a[i],visit[a[i]]++;
    sort(a+1,a+n+1);
    int ans=n;
    for(int i=1,j=n;i<j;)
    {
        if(a[i]+a[j]<=w)///最简单的贪心策略
        {
            ans--;
            i++,j--;
        }
        else j--;
    }
    cout << ans << endl;
    return 0;
}

---

问题 G: 【贪心】IQ

题目：
现在给出一群数学竞赛全体学生的IQ和信息学竞赛全体学生的IQ，问最多能把几个学信息学的学生调去学数学，而两个竞赛的学生平均IQ都有提升呢？
每次只调一个学生，而且每次调配，两个竞赛的学生平均IQ都要提升。
输入
第1行一个正整数N(N≤I00)，代表数学竞赛班学生的数目；
第2行，有N个正整数，代表每个数学学生的IQ（1到200之间）；
第3行，一个整数M(M≤100)，代表信息学竞赛班学生数目；
第4行，有M个正整数，代表每个信息学竞赛班学生的IQ（1到200之间）。
输入数据保证信息学学生平均IQ高于数学学生。
输出
一个正整数，代表能从信息学调去学数学的学生的个数。
思路：
模拟加贪心即可，因为一次只去一个学生，所以比较简单，从小到大排序一遍信息学的学生的IQ，从小的开始判断是否可以去数学竞赛班，可以则改变两个平均值；
排序的原因是要让信息学的学生IQ平均值提升的幅度小一些，保证尽量多的学生可以去，扫一遍即可，无需跑多遍，因为能去的第一轮就去了

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

double a[105],b[105];
int main()
{
    int n;cin>>n;
    double sum1=0,sum2=0;
    for(int i=1;i<=n;i++)cin>>a[i],sum1+=a[i];
    int m;cin>>m;
    for(int i=1;i<=m;i++)cin>>b[i],sum2+=b[i];
    double p1=sum1/n,p2=sum2/m;
    sort(b+1,b+m+1);
    int cnt=0,cnt1=0;
    for(int i=1; i<=m; i++)
    {
        if(b[i]<p2&&b[i]>p1)
        {
            cnt++;
            sum2-=b[i],sum1+=b[i];
            p2=sum2/(m-cnt);
            p1=sum1/(n+cnt);
        }
    }
    cout << cnt << endl;
    return 0;
}

---

问题 N: 【贪心】客户调查

题目:

公司派你去和几位客户面谈，以了解他们对公司产品的意见。你逐个打电话与客户联系，得知他们一般都很忙，不过他们还是可以为你抽出一点时间。现在的问题是有些客户的时间有冲突，你无法在一天内联系所有客户。所以你需要一个程序来帮助你安排这一天的工作，使得你能尽可能地和更多的客户进行联系。注意，客户不愿意你打乱他们的计划。如果你和某个客户约定见面，必须按时到达并且充分利用这段时间和他交谈，这样才不会让他产生不满。你可以假设从一个客户处到另一个客户处的时间短得忽略不计。
输入
共有n+l行，第1行是一个整数n(1≤n≤1000)，表示客户总数。接下来n行每行包括两个正整数s、t，分别表示该客户的空闲时间段的起始时间和终止时间，其中s<t。
输出
仅1行，输出你所能接触到的最多客户数。
思路：
按结束时间排序，结束早的先去这样可以尽量参加多一点会议

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

struct node
{
    int start,endd;
}t[1005];
bool cmp(node a,node b)
{
    if(a.endd==b.endd) return a.start<b.start;
    return a.endd<b.endd;
}
int main()
{
    int n;cin>>n;
    for(int i=1;i<=n;i++) cin>>t[i].start>>t[i].endd;
    sort(t+1,t+n+1,cmp);
    int now=1,cnt=0;
    for(int i=1;i<=n;i++)
    {
        if(now<=t[i].start)
        {
            cnt++;
            now=t[i].endd;
        }
    }
    cout<<cnt<<endl;
    return 0;
}

---

问题 J: 【贪心】货物搬运

题目:
环形的纸牌移动
思路：
把货物变长一倍，暴力枚举前n个位置（长也为n）的纸牌移动的值，取最小值即可
代码：
O(n² )的复杂度，不知道为什么只跑了110ms，可能是数据比较水，或者是OJ上跑得快

#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
int a[20005],b[10005];
int main()
{
    int n; cin>>n;
    long long sum=0;
    for(register int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        a[i+n]=a[i];
        sum+=a[i];
    }
    sum/=n;
    long long minn=1e15;
    for(register int i=1;i<=n;i++)
    {
        for(register int j=i;j<=i+n-1;j++) b[j-i+1]=a[j];
        long long ans=0;
        for(register int j=1;j<=n;j++)
        {
            if(b[j]!=sum)
            {
                ans+=abs(sum-b[j]);
                b[j+1]-=(sum-b[j]);
            }
        }
        minn=min(minn,ans);
    }
    cout<<minn<<endl;
}

---

问题 K: 【贪心】硬币交换

题目：

FZ身上有G1个金币、S1个银币和B1个铜币，而他至少需要G2个金币、S2个银币和B2个铜币。为了完成这个目标，小z只好控制FZ来到了游戏中的银行。银行有如下规定：
(1)你可以用1个金币交换9个银币；
(2)你可以用11个银币交换1个金币；
(3)你可以用1个银币交换9个铜币；
(4)你可以用11个铜币交换1个银币；
问题：最少需要交换多少次硬币才能至少拥有G2个金币、S2个银币和B2个银币呢？
输入
第1行包含三个整数：G1、S1和B1。
第2行包含三个整数：G2、S2和B2。
O≤G1、S1、B1、G2、S2、B2≤l000000。
输出
如果可以完成任务的话，输出文件中应包含一个整数，表示最少交换次数；否则包含一个整数-1。
思路：
将银币换为所需金币和铜币。
判断已有银币和所需银币的大小。
若所需银币大于已有银币，则是Impossible。
反之则模拟次数。
代码：

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int g1,s1,b1,g2,s2,b2,cnt=0;
    cin>>g1>>s1>>b1>>g2>>s2>>b2;
    if(g1<g2)
    {
        s1-=(g2-g1)*11;
        cnt+=g2-g1;
        g1=g2;
    }
    if(b1<b2)
    {
        s1-=ceil(1.0*(b2-b1)/9);
        cnt+=ceil(1.0*(b2-b1)/9);
        b1=b1+ceil(1.0*(b2-b1)/9)*9;
    }
    if(s1 < s2 && g1 > g2)
    {
        if(s1+(g1-g2)*9 < s2)
        {
            cnt+=(g1-g2);
            s1+=(g1-g2)*9;
            s1=s2;
        }
        else
        {
            cnt+=ceil(1.0*(s2-s1)/9);
            g1-=ceil(1.0*(s2-s1)/9);
            s1+=ceil(1.0*(s2-s1)/9)*9;
        }
    }
    if(s1 < s2)
    {
        if(s1+(b1-b2)/11 >= s2)
        {
            cnt+=(b1-b2)/11;
            s1+=(b1-b2)/11;
            b1-=(b1-b2)/11*11;
        }
    }
    if(s1 >= s2)
        cout<<cnt<<endl;
    else
        cout<<-1<<endl;
    return 0;
}

---

问题 S: 【贪心】加工生产调度

题目:
有n个部件需在A、B机器上加工，每个工件都必须经过先A后B两道工序。
已知：部件i在A、B机器上的加工时间分别为ai，bi。
问：如何安排n个工件的加工顺序，才能使得总加工时间最短？
输入
第1行仅一个整数n (0<n<1000)，表示产品的数量；
第2行n个整数，表示这n个产品在A车间加工各自所要的时间（都是整数）；
第3行n个整数，表示这n个产品在B车间加工各自所要的时间（都是整数）。
输出
只有一个数，表示最少的加工时间；
思路：
由少的情况推多的情况：
1）考虑只有两个任务。
机器A一定无空闲直到结束，而机器B必有一段空闲，即刚开始等待A给他第一个任务，我们要让第一个任务在机器A上尽量早结束，所以让ai小的先执行。 这样就可以了吗？ 给出一组样例：任务1={4,1}，任务2={5,3}，我们发现，若先执行任务1，总时间为12，若先执行2再执行1，总时间为10。这是因为任务1的bi太小，其执行完后机器B留下一段时间的空闲。 可见，我们不仅要缩小一开始机器B的等待时间，还要缩小过程中机器B的空闲时间。 缩小空闲时间的方法就是让bi小的尽量留到后面再加工。 综上所述，得出结论：需要考虑两个条件：①ai小的靠前②bi小的靠后。怎样决定一个任务靠前还是靠后呢？任务本身做一个权衡比较ai与bi的大小，遵循小的那一个的条件。至此即可解决两个任务的情况。

2）考虑多个任务
把所有任务分为两类，1类ai<bi，2类ai>bi。至于ai=bi放在哪一类均可，无影响，就因为ai=bi，安排在任意位置，对结果的贡献是不变的。根据（1）中的结论，1类可按ai排序，2类按bi排序，安排后的结果一定是1类全部执行完再执行2类。
代码：

#include <iostream>
#include <algorithm>
using namespace std;
struct node
{
    int time_a,time_b;
    int type;
}e[1005];
bool cmp(node a,node b)
{
    if(a.type==b.type)
    {
        if(a.type==1)  return a.time_b>b.time_b;
        return a.time_a<b.time_a;
    }
    return a.type<b.type;
}
int main()
{
    int n;cin>>n;
    for(int i=1;i<=n;i++) cin>>e[i].time_a;
    for(int i=1;i<=n;i++)
    {
        cin>>e[i].time_b;
        if(e[i].time_a>=e[i].time_b) e[i].type=1;
        else e[i].type=0;
    }
    sort(e+1,e+n+1,cmp);
    int ans=0,temp=0;
    for(int i=1;i<=n;i++)
    {
        temp+=e[i].time_a;
        ans=max(ans,temp)+e[i].time_b;
    }
    cout << ans << endl;
    return 0;
}