bzoj1503

郁闷的出纳员

 HYSBZ - 1503 

OIER公司是一家大型专业化软件公司，有着数以万计的员工。作为一名出纳员，我的任务之一便是统计每位员工的

工资。这本来是一份不错的工作，但是令人郁闷的是，我们的老板反复无常，经常调整员工的工资。如果他心情好

，就可能把每位员工的工资加上一个相同的量。反之，如果心情不好，就可能把他们的工资扣除一个相同的量。我

真不知道除了调工资他还做什么其它事情。工资的频繁调整很让员工反感，尤其是集体扣除工资的时候，一旦某位

员工发现自己的工资已经低于了合同规定的工资下界，他就会立刻气愤地离开公司，并且再也不会回来了。每位员

工的工资下界都是统一规定的。每当一个人离开公司，我就要从电脑中把他的工资档案删去，同样，每当公司招聘

了一位新员工，我就得为他新建一个工资档案。老板经常到我这边来询问工资情况，他并不问具体某位员工的工资

情况，而是问现在工资第k多的员工拿多少工资。每当这时，我就不得不对数万个员工进行一次漫长的排序，然后

告诉他答案。好了，现在你已经对我的工作了解不少了。正如你猜的那样，我想请你编一个工资统计程序。怎么样

，不是很困难吧？

Input

第一行有两个非负整数n和min。n表示下面有多少条命令，min表示工资下界。

接下来的n行，每行表示一条命令。命令可以是以下四种之一：

名称  格式  作用

I命令  I_k  新建一个工资档案，初始工资为k。

                如果某员工的初始工资低于工资下界，他将立刻离开公司。

A命令  A_k  把每位员工的工资加上k

S命令  S_k  把每位员工的工资扣除k

F命令  F_k  查询第k多的工资

_（下划线）表示一个空格，I命令、A命令、S命令中的k是一个非负整数，F命令中的k是一个正整数。

在初始时，可以认为公司里一个员工也没有。

I命令的条数不超过100000 

A命令和S命令的总条数不超过100 

F命令的条数不超过100000 

每次工资调整的调整量不超过1000 

新员工的工资不超过100000

Output

输出行数为F命令的条数加一。

对于每条F命令，你的程序要输出一行，仅包含一个整数，为当前工资第k多的员工所拿的工资数，

如果k大于目前员工的数目，则输出-1。

输出文件的最后一行包含一个整数，为离开公司的员工的总数。

input
9 10
I 60
I 70
S 50
F 2
I 30
S 15
A 5
F 1
F 2
output
10
20
-1
2

sol：此题的权值改变十分有特点（全部加/减），所以可以直接打上一个标记Tag来维护，但是不是所有的点都能加上全部的标记，所以插入的时候要减去标记Tag当前的值，输出的时候加上Tag当前的值。

对于删除（看题解后发现）我们可以插入一个Min-Tag（Min是工资下限）的节点，把所有比它小的都删掉即可

Ps：发现整棵树的大小十分难搞，所以有种方法就是查询inf的排名K，Size就是K-2,（预处理的时候插入-inf和inf）神仙一中ak王yj1.25kAC，然后蔡德仁打了7k

#include <bits/stdc++.h>
using namespace std;
typedef int ll;
inline ll read()
{
    ll s=0;
    bool f=0;
    char ch=' ';
    while(!isdigit(ch))
    {
        f|=(ch=='-'); ch=getchar();
    }
    while(isdigit(ch))
    {
        s=(s<<3)+(s<<1)+(ch^48); ch=getchar();
    }
    return (f)?(-s):(s);
}
#define R(x) x=read()
inline void write(ll x)
{
    if(x<0)
    {
        putchar('-'); x=-x;
    }
    if(x<10)
    {
        putchar(x+'0');    return;
    }
    write(x/10);
    putchar((x%10)+'0');
    return;
}
#define W(x) write(x),putchar(' ')
#define Wl(x) write(x),putchar('
')
const int N=1000005,inf=0x3f3f3f3f;
int Q,Min;
namespace Pht
{
    int Points,Root,Tag=0;
    int Child[N][2];
    int Parent[N];
    int Cnt[N];
    int Size[N];
    int Quanzhi[N];
    
    inline void Init();
    inline int check(int x);
    inline void PushUp(int x);
    inline void Rotate(int x);
    inline void Splay(int At,int To);
    inline void Insert(int Val);
    inline void Remove(int Val);
    inline int Find(int Val,int opt);
    inline int Ask_Rank(int Val,int opt);
    inline int Ask_Kth(int Id);
    inline int Ask_Lower(int Val);
    inline int Ask_Upper(int Val);
    inline int Find_Min();
    inline void Solve();
    
    inline void Init()
    {
        Points=Root=0;
        Insert(-inf);
        Insert(inf);
    }
    inline int Check(int x)
    {
        return (Child[Parent[x]][0]==x)?0:1;
    }
    inline void PushUp(int x)
    {
        Size[x]=Size[Child[x][0]]+Size[Child[x][1]]+Cnt[x];
    }
    inline void Rotate(int x)
    {
        int y,z,oo;
        y=Parent[x];
        z=Parent[y];
        oo=Check(x);
        Child[y][oo]=Child[x][oo^1]; Parent[Child[x][oo^1]]=y;
        Child[z][Check(y)]=x; Parent[x]=z;
        Child[x][oo^1]=y; Parent[y]=x;
        PushUp(x); PushUp(y);
    }
    inline void Splay(int At,int To)
    {
        while(Parent[At]!=To)
        {
            int Father=Parent[At];
            if(Parent[Father]==To)
            {
                Rotate(At);
            }
            else if(Check(At)==Check(Father))
            {
                Rotate(Father); Rotate(At);
            }
            else
            {
                Rotate(At); Rotate(At);
            }
        }
        if(To==0) Root=At;
    }
    inline void Insert(int Val)
    {
        int Now=Root,Par=0;
        while(Now&&(Quanzhi[Now]!=Val))
        {
            Par=Now;
            Now=Child[Now][(Val>Quanzhi[Now])?1:0];
        }
        if(Now)
        {
            Cnt[Now]++; Size[Now]++;
        }
        else
        {
            Now=++Points;
            if(Par) Child[Par][(Val>Quanzhi[Par])?1:0]=Now;
            Child[Now][0]=Child[Now][1]=0;
            Parent[Now]=Par;
            Cnt[Now]=Size[Now]=1;
            Quanzhi[Now]=Val;
        }
        Splay(Now,0);
    }
    inline void Remove(int Val)
    {
        int Lower=Ask_Lower(Val),Upper=Ask_Upper(Val);
        Splay(Lower,0);
        Splay(Upper,Lower);
        if(Cnt[Child[Upper][0]]>1)
        {
            Cnt[Child[Upper][0]]--; Size[Child[Upper][0]]--; Splay(Child[Upper][0],0);
        }
        else
        {
            Child[Upper][0]=0;
        }
    }
    inline int Find(int Val,int opt)
    {
        int Now=Root;
        while(Child[Now][(Val>Quanzhi[Now])?1:0]&&(Quanzhi[Now]!=Val))
        {
            Now=Child[Now][(Val>Quanzhi[Now])?1:0];
        }
        if(opt) Splay(Now,0);
        return Now;
    }
    inline int Ask_Rank(int Val,int opt)
    {
        int Now=Root,Sum=0;
        for(;;)
        {
            if(Val<Quanzhi[Now]) Now=Child[Now][0];
            else
            {
                Sum+=Size[Child[Now][0]];
                if(Val==Quanzhi[Now])
                {
                    if(opt) Splay(Now,0);
                    return Sum+1;
                }
                Sum+=Cnt[Now];
                Now=Child[Now][1];
            }
        }
    }
    inline int Ask_Kth(int Id)
    {
        int Now=Root;
        for(;;)
        {
            if(Size[Child[Now][0]]>=Id)
            {
                Now=Child[Now][0];
            }
            else if(Size[Child[Now][0]]+Cnt[Now]>=Id)
            {
                return Now;
            }
            else
            {
                Id-=(Size[Child[Now][0]]+Cnt[Now]);
                Now=Child[Now][1];
            }
        }
    }
    inline int Ask_Lower(int Val)
    {
        Find(Val,1);
        int Now=Root;
        if(Quanzhi[Now]<Val) return Now;
        Now=Child[Now][0];
        while(Child[Now][1]) Now=Child[Now][1];
        return Now;
    }
    inline int Ask_Upper(int Val)
    {
        Find(Val,1);
        int Now=Root;
        if(Quanzhi[Now]>Val) return Now;
        Now=Child[Now][1];
        while(Child[Now][0]) Now=Child[Now][0];
        return Now;
    }
    inline void Solve()
    {
        int tot=0;
        Init();
        while(Q--)
        {
            char ch=' ';
            while(!isupper(ch)) ch=getchar();
            int x=read(),a,b,Pos;
            switch (ch)
            {
                case 'I':
                    if(x>=Min)
                    {
                        Insert(x-Tag); tot++;
                    }
                    break;
                case 'A':
                    Tag+=x;
                    break;
                case 'S':
                    Tag-=x;
                    Insert(Min-Tag);
                    a=Find(-inf,0); b=Find(Min-Tag,0);
                    Splay(a,0);
                    Splay(b,a);//Root=a Child[a][1]=b
                    Child[b][0]=0;
                    Cnt[b]--;
                    Splay(b,0);
                    break;
                case 'F':
                    int Nowtot=Ask_Rank(inf,0)-2;
                    if(Nowtot<x)
                    {
                        puts("-1");
                    }
                    else
                    {
                        x=Nowtot-x+1;
                        Wl(Quanzhi[Ask_Kth(x+1)]+Tag);
                    }
                    break;
            }
        }
        Wl(tot-(Ask_Rank(inf,0)-2));
    }
}
int main()
{
    R(Q); R(Min);
    Pht::Solve();
    return 0;
}
/*
input
9 10
I 60
I 70
S 50
F 2
I 30
S 15
A 5
F 1
F 2
output
10
20
-1
2
*/