[NOI2004]郁悶的出納員

題目描述

OIER公司是一家大型專業化軟件公司，有著數以萬計的員工。作為一名出納員，我的任務之一便是統計每位員工的工資。這本來是一份不錯的工作，但是令人郁悶的是，我們的老板反復無常，經常調整員工的工資。如果他心情好，就可能把每位員工的工資加上一個相同的量。反之，如果心情不好，就可能把他們的工資扣除一個相同的量。我真不知道除了調工資他還做什麽其它事情。

工資的頻繁調整很讓員工反感，尤其是集體扣除工資的時候，一旦某位員工發現自己的工資已經低於了合同規定的工資下界，他就會立刻氣憤地離開公司，並且再也不會回來了。每位員工的工資下界都是統一規定的。每當一個人離開公司，我就要從電腦中把他的工資檔案刪去，同樣，每當公司招聘了一位新員工，我就得為他新建一個工資檔案。

老板經常到我這邊來詢問工資情況，他並不問具體某位員工的工資情況，而是問現在工資第k多的員工拿多少工資。每當這時，我就不得不對數萬個員工進行一次漫長的排序，然後告訴他答案。

好了，現在你已經對我的工作了解不少了。正如你猜的那樣，我想請你編一個工資統計程序。怎麽樣，不是很困難吧？

如果某個員工的初始工資低於最低工資標準,那麽將不計入最後的答案內

輸入輸出格式

輸入格式：

第一行有兩個非負整數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是一個正整數。

在初始時，可以認為公司裏一個員工也沒有。

輸出格式：

輸出文件的行數為F命令的條數加一。

對於每條F命令，你的程序要輸出一行，僅包含一個整數，為當前工資第k多的員工所拿的工資數，如果k大於目前員工的數目，則輸出-1。

輸出文件的最後一行包含一個整數，為離開公司的員工的總數。

輸入輸出樣例

輸入樣例#1：

9 10
I 60
I 70
S 50
F 2
I 30
S 15
A 5
F 1
F 2

輸出樣例#1：

10
20
-1
2

說明

I命令的條數不超過100000

A命令和S命令的總條數不超過100

F命令的條數不超過100000

每次工資調整的調整量不超過1000

新員工的工資不超過100000

平衡樹的裸題，這裏使用了替罪羊樹，突然發現之前打的板子是個假的，在重構的時候只判斷了子樹的重構，沒有判斷整棵樹的重構。

#include<bits/stdc++.h>
#define il inline
using namespace std;
int read()
{
    int x=0,w=1;char ch=getchar();
    while(ch>'9'||ch<'0') {if(ch=='-')w=-1;ch=getchar();}
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
    return x*w;
}
const int N=210010;
double alpha=0.75;
int n,ming,cnt,lazy,root,need,top,x,num;char qwe[5];
int s[N];
struct node{
    int son[2],v,size,die;
}tree[N];
int exist(int k){return (tree[k].die^1);}
il bool bad(int k)
{
    int k1=tree[k].son[0],k2=tree[k].son[1];
    return (double)max(tree[k1].size,tree[k2].size)>=(double)tree[k].size*1.0*alpha;
}
il void push_up(int k)
{
    tree[k].size=tree[tree[k].son[0]].size+tree[tree[k].son[1]].size+exist(k);
}
il void dfs(int k)
{
    if(!k) return;
    dfs(tree[k].son[0]);if(!tree[k].die)s[++top]=k;dfs(tree[k].son[1]);
}
il void build(int &k,int l,int r)
{
    if(l>r) return;int mid=(l+r)/2;k=s[mid];
    if(l==r)
    {
        tree[k].son[0]=tree[k].son[1]=tree[k].die=0;
        tree[k].size=1;return;
    }
    if(l<mid) build(tree[k].son[0],l,mid-1);
    else tree[k].son[0]=0;
    if(r>mid) build(tree[k].son[1],mid+1,r);
    else tree[k].son[1]=0;
    int k1=tree[k].son[0],k2=tree[k].son[1];
    tree[k].size=tree[k1].size+tree[k2].size+1;
}
il void rebuild(int &k)
{
    top=0;dfs(k);if(top)build(k,1,top);else k=0;
}
il void insert(int &k,int v)
{
    if(!k)
    {
        k=++cnt;tree[k].v=v;tree[k].size=1;tree[k].die=0;return;
    }
    tree[k].size++;
    if(v<=tree[k].v) insert(tree[k].son[0],v);
    else insert(tree[k].son[1],v);
    if(!bad(k))
    {
        if(need)
        {
            if(tree[k].son[0]==need) rebuild(tree[k].son[0]);
            else rebuild(tree[k].son[1]);
        }
        need=0;
    }
    else need=k;
}
il void delet(int k,int v)
{
    if(!k) return;
    int k1=tree[k].son[0],k2=tree[k].son[1];
    if(!tree[k].die&&tree[k1].size+1==v)
    {
        tree[k].die=1;tree[k].size=tree[k2].size;tree[k].son[0]=0;num+=tree[k1].size+1;return;
    }
    if(tree[k1].size+exist(k)>=v) delet(k1,v);
    else 
    {
        delet(k2,v-tree[k1].size-exist(k));tree[k].son[0]=0;num+=tree[k1].size+exist(k);tree[k].die=1;
    }
    push_up(k);
    if(!bad(k))
    {
        if(need)
        {
            if(tree[k].son[0]==need) rebuild(tree[k].son[0]);
            else rebuild(tree[k].son[1]);
        }
        need=0;
    }
    else need=k;
}
il int getrank(int k,int v)
{
    if(!k) return 0;
    int k1=tree[k].son[0],k2=tree[k].son[1];
    if(tree[k].v<v) return getrank(k2,v)+tree[k1].size+exist(k);
    return getrank(k1,v);
}
il int kth(int k,int v)
{
    if(!k) return -1;
    int k1=tree[k].son[0],k2=tree[k].son[1];
    if(!tree[k].die&&tree[k2].size+1==v) return tree[k].v+lazy;
    if(tree[k2].size>=v) return kth(k2,v);
    return kth(k1,v-tree[k2].size-exist(k));
}
int main()
{
    n=read();ming=read();
    for(int i=1;i<=n;i++)
    {
        scanf("%s",qwe);x=read();
        if(qwe[0]=='I') {if(x>=ming)insert(root,x-lazy);if(need)rebuild(root),need=0;}
        else if(qwe[0]=='A') lazy+=x;
        else if(qwe[0]=='S')
        {
            lazy-=x;
            int d=getrank(root,ming-lazy);
            if(d!=0)delet(root,d);if(need)rebuild(root),need=0;
        }
        else if(qwe[0]=='F') printf("%d\n",kth(root,x));
    }
    cout<<num<<endl;
    return 0;
}

[NOI2004]郁悶的出納員（平衡樹）