OJ Problem 1700:Swap the rank

第一次写，没啥经验，见谅

题目描述：

小灰灰参加了n场培训，在第i场培训中，小灰灰的排名是ai，这场培训的合格标准是bi，只有当ai<=bi的时候,小灰灰才算在第i场培训中合格。小灰灰为了使自己n场培训全部合格，准备使用一个黑客软件去交换一些场次的排名。但是这个黑客软件是付费的，小灰灰想要对某一个场次进行操作，就必须要付c元去控制这个场次。例如，小灰灰花费3*c元去控制场次1，3，4,小灰灰就可以任意交换场次1，3，4自己的排名了。现在，小灰灰希望花费尽量少的费用去使自己n场培训全部合格，你需要计算最小费用是多少。

输入要求

第一行输入一个n，c
接下来n行每行两个数ai bi
1<=n<=5000
1<=c,ai,bi<=200000
保证输入都是整数

输出要求

输出一个整数表示阿狸花费最小费用。如果小灰灰不能通过交换排名使自己去n场比赛中都合格，输出-1。

样例输入

样例输出

样例解释

控制第1、3、4场，交换后序列变为：

666 6666
66 6666
66 66
6 6

思路：

这是个有趣的贪心问题，没想象的那么复杂。
首先有一部分是必须换的，反正必须换不妨换个彻底，将place最大的与cutoff最大的匹配，place最小的与cutoff最小的匹配。
如果成立就结束。
不成立的话，再试图引入一个外部项，这步贪心即可。

程序代码：

1. 一般IDE能跑不能过（超时）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <memory.h>

#define x first
#define y second

using namespace std;

typedef pair<int,int> PII;

int main()
{
    int n,c;
    cin>>n>>c;
    PII s[n];
    bool flags[n];
    memset(flags,false,sizeof(flags));//初始化数组均为false

    int a,b;
    for(int i = 0; i < n; ++i)
    {
        cin>>a>>b;
        s[i].x = b,s[i].y = a;
    }//输入数据

    sort(s,s+n);//对数据排序

    int t = n;
    while(t--)//以防“前院失火”情况
    {
        for(int i = n - 1; i >= 0; --i)
        {
            if(s[i].y > s[i].x)//判断是否存在不及格情况，进行处理
            {
                int j;
                for(j = i; j < n; ++j)
                {
                    if(s[i].y <= s[j].x)
                    {
                        int ranking[n];
                        for(int i = 0; i < n; ++i)
                            ranking[i] = s[i].y;//每次提取实际排名情况

                        int location = j,min_x = ranking[j];

                        for(int k = j; k < n; ++k)
                        {
                            if(ranking[k] < min_x && ranking[k] != s[i].y)
                            {
                                location = k;
                                min_x = ranking[k];
                            }
                        }//寻找最小值

                        int temp = s[i].y;
                        s[i].y = s[location].y;
                        s[location].y = temp;//交换位置

                        flags[i] = true;
                        flags[location] = true;
                        break;
                    }
                    else
                        continue;
                }
            }
        }
    }

    int cnt = 0;
    for(int i = 0; i < n; ++i)
    {
        if(flags[i])
            cnt++;
    }//获取交换过数据的次数

    bool flag = true;
    for(int i = 0; i < n; ++i)
    {
        if(s[i].y > s[i].x)
            flag = false;
    }//判断是否全部合格

    if(flag == false)
        printf("-1");
    else
        printf("%d",c * cnt);//输出结果

    return 0;
}

2. 未超时版

#include <cstdio>
#include <iostream>
#include <algorithm>

using namespace std;

void ins(int *a, int k, int x)//插入函数
{
    while (k && a[k - 1] > x)
    {
        a[k] = a[k - 1];
        k--;
    }
    a[k] = x;
}

int main()
{
    int n,c;
    cin >> n >> c;
    int p[n], A[n], cnt = 0;
    int f[n], a[n], fcnt = 0;
    int x, y;
    for (int i = 0; i < n; i++)
    {
        cin >> x >> y;
        if (x <= y)//判断及格与否并将两种情况分开存储
        {
            p[cnt] = x;
            A[cnt++] = y;
        }
        else
        {
            f[fcnt] = x;
            a[fcnt++] = y;
        }
    }

    //将不及格情况进行排序
    sort(f, f + fcnt);
    sort(a, a + fcnt);

    while (true)
    {
        int fail = fcnt - 1;
        while(fail >= 0 && f[fail] <= a[fail])//判断排序后不及格情况是否仍然存在
        {
            fail--;//若存在，则标记位置
        }
        if (fail < 0)
        {
            break;//若不存在，则跳出循环，结束程序
        }

        int tag = -1;
        for (int i = 0; i < cnt; i++)
        {
            //期望找到能交换的一对数并保证交换后两个都变为及格(最期望)
            if (p[i] <= a[fail] && A[i] >= f[fail] && (tag == -1 || p[i] < p[tag] /*保证p[i]是最小的*/ ))
            {
                tag = i;
            }
        }
        if (tag < 0)//若上述期望未实现
        {
            for (int i = 0; i < cnt; i++)
            {
                //再次期望找到一组数仅保证主动交换的一组数及格，不能保证被动交换的一组数一定及格
                if (f[fail] <= A[i] && (tag == -1 || p[i] < p[tag] /*保证p[i]是最小的*/ ))
                {
                    tag = i;
                }
            }
        }
        if (tag < 0)//上述期望均未实现
        {
            cout<<"-1";
            return 0;//程序结束
        }
        //若上述期望实现之一，将被动交换的一组数插入到未及格的数组中
        ins(f, fcnt, p[tag]);
        ins(a, fcnt, A[tag]);
        //更新
        fcnt++;
        cnt--;
        //将及格数组中最后的一组数填补到已交换(此处的交换并没有及格的数组数据)的数组中
        p[tag] = p[cnt];
        A[tag] = A[cnt];
    }

    printf("%d", fcnt * c);

    return 0;
}

• 若有问题，欢迎交流