【20CSPS提高组】贪吃蛇

2011：【20CSPS提高组】贪吃蛇

时间限制: 2000 ms         内存限制: 262144 KB
提交数: 748     通过数: 189

【题目描述】

草原上有 n 条蛇，编号分别为 1,2,⋯,n。初始时每条蛇有一个体力值ai，我们称编号为 x 的蛇实力比编号为 y 的蛇强当且仅当它们当前的体力值满足 ax>ay，或者 ax=ay 且 x>y。

接下来这些蛇将进行决斗，决斗将持续若干轮，每一轮实力最强的蛇拥有选择权，可以选择吃或者不吃掉实力最弱的蛇：

1.如果选择吃，那么实力最强的蛇的体力值将减去实力最弱的蛇的体力值，实力最弱的蛇被吃掉，退出接下来的决斗。之后开始下一轮决斗。

2.如果选择不吃，决斗立刻结束。

每条蛇希望在自己不被吃的前提下在决斗中尽可能多吃别的蛇（显然，蛇不会选择吃自己）。

现在假设每条蛇都足够聪明，请你求出决斗结束后会剩几条蛇。

本题有多组数据，对于第一组数据，每条蛇体力会全部由输入给出，之后的每一组数据，会相对于上一组的数据，修改一部分蛇的体力作为新的输入。

【输入】

第一行一个正整数 T，表示数据组数。

接下来有 T 组数据，对于第 1 组数据，第一行一个正整数 n，第二行 n个非负整数表示 ai。

对于第 2 组到第 T 组数据，每组数据：

第一行第一个非负整数 k 表示体力修改的蛇的个数。

第二行 2k 个整数，每两个整数组成一个二元组 (x,y)，表示依次将 ax的值改为 y。一个位置可能被修改多次，以最后一次修改为准。

【输出】

输出 T 行，每行一个整数表示最终存活的蛇的条数。

【输入样例】

2
3
11 14 14
3
1 5 2 6 3 25

【输出样例】

3
1

【提示】

【样例 1 解释】

第一组数据，第一轮中 3 号蛇最强，1 号蛇最弱。若 3 号蛇选择吃，那么它将在第二轮被 2 号蛇吃掉。因此 3 号蛇第一轮选择不吃，3 条蛇都将存活。

对于第二组数据，3 条蛇体力变为 5,6,25。第一轮中 3 号蛇最强，1 号蛇最弱，若它选择吃，那么 3 号蛇体力值变为 20，在第二轮中依然是最强蛇并能吃掉 2 号蛇，因此 3 号蛇会选择两轮都吃，最终只有 1 条蛇存活。

【样例 2 输入】

2
5
13 31 33 39 42
5
1 7 2 10 3 24 4 48 5 50

【样例 2 输出】

5
3

【数据范围与提示】

对于 20%的数据：n=3。

对于 40%的数据：n≤10。

对于 55%的数据：n≤2000。

对于 70%的数据：n≤5×104。

对于 100%的数据：3≤n≤106，1≤T≤10，0≤k≤105，0≤ai,y≤109。保证每组数据（包括所有修改完成后的）的 ai 以不降顺序排列。

代码：

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int N=1e6+100,INF=1e9;
struct Node
{
    int val,num;
    #define val(i) a[i].val
    #define num(i) a[i].num
    bool operator < (const Node y)
    {
        return val==y.val?num<y.num:val<y.val;
    }
    bool operator == (const Node y)
    {
        return val==y.val && num==y.num;
    }
}a[N];
int T,n,k,ph,pb;
queue<Node> q;
Node blank={0,0},black={INF,INF};
Node Max(Node x,Node y)
{
    return (x<y)?y:x;
}
Node Min(Node x,Node y)
{
    return (x<y)?x:y;
}
bool query(Node la)//传入上一次操作后的元素
{
    int cnt=0;
    Node bk=Min(pb<ph?a[pb+1]:black,q.size()?q.back():black);//次小元素
    while(1)
    {
        Node hd=Max(pb<ph?a[ph]:blank,q.size()?q.front():blank);//最大元素
        if(a[ph]==hd)
            ph--;
        else
            if(q.size())
                q.pop();//维护指针和队列
        if(hd==bk)
            break;//只剩两个元素，即次小元素与最大元素相等
        hd.val-=la.val;
        if(bk<hd)
            break;//当前最大的元素操作后不是最小的元素
        la=hd;cnt++;//维护指针
    }
    return cnt&1;//在第 x 次操作终止，返回 x-1 的奇偶性
}
int main()
{
    scanf("%d",&T);
    for(int i=1;i<=T;i++)
    {
        if(i==1)
        {
            scanf("%d",&n);
            for(int j=1;j<=n;j++)
                scanf("%d",&val(j)),num(j)=j;
        }
        else
        {
            scanf("%d",&k);
            for(int j=1,x,y;j<=k;j++)
            {
                scanf("%d%d",&x,&y);
                val(x)=y;
            }
        }
        ph=n,pb=1;//分别为原序列最大元素和最小元素的指针
        while(q.size())
            q.pop();
        while(pb<=ph)
        {
            Node x=Max((ph>pb)?a[ph]:blank,q.size()?q.front():blank);//最大元素
            if(a[ph]==x)
                ph--;
            else
                q.pop();//维护指针和队列
            x.val-=val(pb);
            if(x<a[pb+1] && n-pb>1)//当前最大的元素操作后是最小的元素且剩下的元素不止一个
            {
                if(query(x))//求解是否进行本次操作
                    pb++;
                break;
            }
            q.push(x);pb++;//维护指针和队列
        }
        printf("%d\n",n-pb+1);
    }
    return 0;
}