bzoj3709: [PA2014]Bohater 贪心

~~~题面~~~

题解：

　　首先有一个比较明显的策略，肯定先要把能带给自己受益的先选完，然后再以最佳状态去打那些会给自己带来损失的怪。

　　对于前一部分（可以带来受益的怪），显然我们需要先从代价小的打起，因为这样可以把生命值越积越多，打代价大的怪也更容易成功。

　　那么对于后一部分怎么办呢？我们需要从受益大的打起，为什么？

　　证明：

　　　　假设一个怪的受益为back,代价为cost,那么首先假设我们打完所有怪之后剩下have的生命值，那么have的大小是固定的，不会随着操作顺序而改变，因此我们可以考虑用这个来倒推最优策略。

　　　　那么就是要使得这个倒推尽可能成功，观察一下，在倒推的过程中，相当于是不断的后悔打某个怪，那么就相当于减去back，加上cost。

　　　　因此这就是一个和上一部分类似的问题，所以在倒推的时候需要按照back从小到大取，那么从正向来看，就是按照back从大到小取。

 

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 250100
#define LL long long
 
int n;
LL have;
int q[AC], top;
struct node{
    int cost, back, id;
}s[AC];
 
inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}
 
inline bool cmp1(node a, node b){
    return a.cost < b.cost;
}
 
inline bool cmp2(node a, node b){
    return a.back > b.back;
}
 
void pre()
{
    n = read(), have = read();
    for(R i = 1; i <= n; i ++) 
        s[i].cost = read(), s[i].back = read(), s[i].id = i;
}
 
void work()
{
    sort(s + 1, s + n + 1, cmp1);
    for(R i = 1; i <= n; i ++)
        if(s[i].cost <= s[i].back) 
        {
            if(s[i].cost >= have) {printf("NIE\n"); return ;}
            have += s[i].back - s[i].cost;
            q[++top] = s[i].id;
        }
    sort(s + 1, s + n + 1, cmp2);
    for(R i = 1; i <= n; i ++)
        if(s[i].cost > s[i].back) 
        {
            if(s[i].cost >= have) {printf("NIE\n"); return ;}
            have += s[i].back - s[i].cost;
            q[++top] = s[i].id;
        }
    printf("TAK\n");
    for(R i = 1; i <= top; i ++) printf("%d ", q[i]);
}
 
int main()
{
    //freopen("in.in", "r", stdin);
    pre();
    work();
    //fclose(stdin);
    return 0;
}