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('\n')
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
*/
View Code

 

 

河田は河田、赤木は赤木……。 私は誰ですか。教えてください、私は誰ですか。 そうだ、俺はあきらめない男、三井寿だ!
posted @ 2019-04-09 20:23  人间不值の  阅读(185)  评论(0编辑  收藏  举报