贪心专题(不定期更新)

1、UVa 10382 - Watering Grass (贪心—区间覆盖)

　　题意：一块矩形草坪，给出若干个分布在中轴线上的喷水装置，喷水范围为圆形。问能否覆盖整个草坪，若能，求出最少的喷水装置数目。

　　思路：圆形半径小于等于草坪宽度一半的不用考虑；在剩下的喷水圆形区域中，求出对应覆盖草坪的矩形区块，之后则进行贪心处理:找出矩形区块[L,R]左侧L小于等于当前已覆盖区域的右侧POS的区块中，右侧R最大的那个，同时更新POS.

　　

#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
struct sprk
{
    double r,ldis;
    double L, R;
}v[10005];
double n, l, w;
bool Cmp(const sprk& a, const sprk& b)
{
    if (a.L < b.L) return true;
    else if (a.L == b.L)
    {
        if (a.R < b.R) return true;
        else return false;
    }
    else return false;
}
int main()
{
    while (cin >> n >> l >> w)
    {
        int sz = 0;
        sprk tmp;
        for (int i = 0; i < n; i++)
        {
            cin >> tmp.ldis >> tmp.r;
            if (tmp.r <=w/2.0) continue;
            double tl = sqrt(tmp.r*tmp.r-w*w/4.0);
            tmp.L = tmp.ldis*1.0 - tl;
            tmp.R = tmp.ldis*1.0 + tl;
            if (tmp.R < 0) continue;
            v[sz++] = tmp;
        }
        sort(v, v+sz, Cmp);
        int num = 0;
        double pos = 0;
        int k = 0;
        bool ok = false;
        if (sz>0&&v[0].L <= 0)
        {
            k = 0;
            pos = 0;
            while (k < sz)
            {
                int j = k;
                double Rpos = pos;
                while (j < sz&&v[j].L <= pos)
                {
                    if (v[j].R > Rpos) Rpos = v[j].R;
                    ++j;
                }
                if (j == k)break;
                num++;
                pos = Rpos;
                k = j;
                if (pos >= l)
                {
                    ok = true;
                    break;
                }
            }
        }
        if(ok) cout << num << endl;
        else cout << -1 << endl;
    }
    return 0;
}

2、Uva10905 Children's Game

　　题意：给出若干个数字，把这些数字重新组合成一个新的数字，要求这个数字的字典序最大。

　　思路：用字符串保存；从大到小排序，关键为比较函数：把两个字符串按先后顺序重新组合成两个新的字符串，比较两个新字符串的字典序大小，字典序大的新字符串的第一个子字符串如果是传入比较函数的第一个参数，则为true，否则为false。

#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
using namespace std;
string s[55];
int n;
bool Cmp(const string &a, const string &b)
{
    string tmp1 = a + b;
    string tmp2 = b + a;
    if (tmp1 > tmp2) return true;
    else return false;
}
int main()
{
    while (cin >> n, n != 0)
    {
        for (int i = 0; i < n; i++) cin >> s[i];
        sort(s, s + n, Cmp);
        for (int i = 0; i < n; i++)
        {
            cout << s[i];
        }
        cout << endl;
    }
    return 0;
}

3、UVA 11134 Fabled Rooks

　　题意：给出n*n的棋盘，以及n个棋子的限制放置的矩形区域(给出左上顶点(xl,yl)和右下顶点的坐标(xr,yr))。要求每行每列只能有一个棋子。求任意一种方案，若无，则输出impossible

　　思路：分别对行和列进行贪心处理，贪心过程和第一题相似：对于行r(列c),找到xl≤r,xr≥r(yl≤c,yr≥c)且未被选取的棋子中，xr(yr)最小的那个，使其x(y)坐标为r(c).

#include<iostream>
#include<algorithm>
#include<memory.h>
using namespace std;
const int maxn = 5005;
struct node
{
    int id;
    int xl, yl, xr, yr;
    int x, y;
}ch[maxn];
bool vis[maxn];
int n;
bool flag = true;
void CalX()
{
    memset(vis, 0, sizeof(vis));
    int r = 1;
    for (int i = 0; i < n; i++)
    {
        int minr = maxn;
        int pos;
        for (int j = 0; j < n; j++)
        {
            if (!vis[j] && ch[j].xl <= r&&ch[j].xr >= r&&ch[j].xr < minr)
            {
                minr = ch[j].xr;
                pos = j;
            }
        }
        if (minr == maxn)
        {
            flag = false;
            return;
        }
        vis[pos] = true;
        ch[pos].x = r;
        r++;
    }
}
void CalY()
{
    memset(vis, 0, sizeof(vis));
    int c = 1;
    for (int i = 0; i < n; i++)
    {
        int minc = maxn;
        int pos;
        for (int j = 0; j < n; j++)
        {
            if (!vis[j] && ch[j].yl <= c&&ch[j].yr >= c&&ch[j].yr < minc)
            {
                minc = ch[j].yr;
                pos = j;
            }
        }
        if (minc == maxn)
        {
            flag = false;
            return;
        }
        vis[pos] = true;
        ch[pos].y = c;
        c++;
    }
}
int main()
{
    while (cin >> n, n != 0)
    {
        flag = true;
        for (int i = 0; i < n; i++)
        {
            cin >> ch[i].xl >> ch[i].yl >> ch[i].xr >> ch[i].yr;
            ch[i].id = i + 1;
        }
        CalX();
        if(flag) CalY();
        if (flag)
        {
            for (int i = 0; i < n; i++)
            {
                cout << ch[i].x << ' ' << ch[i].y << endl;
            }
        }
        else cout << "IMPOSSIBLE
";
    }
    return 0;
}

4、poj 3045 Cow Acrobats(贪心, 二分) 

　　题意：有n头牛，每头牛有其重量wi,力气si.将这些牛叠罗汉,每头牛都有一定的风险使整个叠罗汉崩塌，风险值为其上面牛的总重减去该牛的力气。求在所有种叠罗汉的顺序中，最小的风险值。

　　思路：先考虑最底下一头牛，设其风险值为（sum+w1）-(w1+s1)，因为如果把其换成其他牛，sum+w1不变，但w1+s1有变。所以贪心地处理，wi+si大的放下面；然后考虑剩下的n-1头牛，该哪头放在从底向上的第二个位置呢？同理，可知把这n-1头牛中wi+si最大的放在该位置。其他类似

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 50005;
struct Cow
{
    int w;
    int s;
}cows[maxn];

bool Cmp(const Cow&a, const Cow&b)
{
    if (a.s + a.w > b.s + b.w)  return true;
    else if (a.s + a.w == b.s + b.w) return a.s > b.s;
    else return false;
}

int n;
int main()
{
    while (cin >> n)
    {
        for (int i = 0; i < n; i++) cin >> cows[i].w >> cows[i].s;
        sort(cows, cows + n, Cmp);
        long long risk = 0 - cows[n - 1].s;
        long long ans = risk;
        for (int i = n - 2; i >= 0; i--)
        {
            risk = risk + cows[i + 1].w + cows[i + 1].s - cows[i].s;
            ans = max(ans, risk);
        }
        printf("%lld
", ans);
    }
    return 0;
}

 5、hdu 1789 Doing Homework again

　　题意：需要完成n种功课，每种都有自己的截止日期和迟交的扣去的学分。假设完成一门功课的时间为1天。问最少会扣多少学分。

　　思路：贪心处理，先按照截止日期大的排序，每次从其截止日前往前找第一个空闲的日子做该作业，如果找不到，只能扣学分。

#include<iostream>
#include<algorithm>
#include<memory.h>
#include<cstdio>
using namespace std;
const int maxn = 1010;
struct node
{
    int dscore;
    int deadline;
}homeworks[maxn];
bool Cmp(const node&a, const node&b)
{
    if (a.dscore == b.dscore) return a.deadline < b.deadline;
    else return a.dscore > b.dscore;
}

bool vis[maxn];
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int n;
        scanf("%d", &n);
        for (int i = 0; i < n; i++) scanf("%d", &homeworks[i].deadline);
        for (int i = 0; i < n; i++) scanf("%d", &homeworks[i].dscore);
        sort(homeworks, homeworks + n, Cmp);
        memset(vis, 0, sizeof(vis));
        int sum = 0;
        for (int i = 0; i < n; i++)
        {
            int t = homeworks[i].deadline;
            int j;
            for (j = t; j >= 1; --j)
            {
                if (!vis[j])
                {
                    vis[j] = true;
                    break;
                }
            }
            if (j < 1) sum += homeworks[i].dscore;
        }
        printf("%d
", sum);
    }
    return 0;
}

 6、hdu 1257 最少拦截系统

　　题意：每个拦截系统的第一发能够达到任意高度，但之后的拦截导弹的高度不能超过之前的。现在有一大批导弹袭来，问最少的拦截系统个数。

　　思路：如果当前所有拦截系统可到达的高度都不能拦截该导弹，则新增一个拦截系统，高度为该导弹的高度；否则，选择当前拦截系统中高度大于等于该导弹高度的最小的那个去拦截。

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 10010;
const int INF = 0x7fffffff;
int sys[maxn];
int main()
{
    int n;
    while (~scanf("%d", &n))
    {
        int cnt = 0;
        for (int i = 1; i <= n; i++)
        {
            int h;
            scanf("%d", &h);
            bool flag = false;
            int pos = 0;
            int mindis = INF;
            for (int i = 0; i < cnt; i++)
            {
                if (sys[i] >= h)//找到当前拦截系统高度与导弹高度最接近的去拦截
                {
                    if (sys[i] - h < mindis)
                    {
                        mindis = sys[i] - h;
                        pos = i;
                        flag = true;
                    }
                }
            }
            if (flag) sys[pos] = h;
            else
            {
                sys[cnt++] = h;
            }
        }
        printf("%d
", cnt);
    }
    return 0;
}