【Treap 例题】神秘岛（island）

神秘岛（island）

题目描述：

除了敲代码和撩妹，旅行是cxw123 的第三爱好。
他来到了澳大利亚东北部的大宝礁，在这里，有一个隔绝人世的神秘岛，这个岛不同于附近
其他的珊瑚岛，它的生长速度极快，甚至以每日可见的速度延伸拓展。
岛上的居民十分担心自己将来无处可居，于是委托远道而来的cxw123 阅读该岛的地理日
志，请他帮助分析该岛每日的变换。
已知该岛的地理日志涵盖以下内容：
高度H，可居住岛屿距离海平面的高度必须大于等于H。
1.珊瑚礁生长：当日有一个新的岛屿生长了出来，记录了它现在距离海平面的高度，
且其绝对高度不会改变。
2.海水上涨：记录了当日海平面升高的高度。
3.海水下降：记录了当日海平面下降的高度。
请注意：

1.一旦某个岛屿某个时刻距离海平面的高度小于高度H，它将被海水侵蚀，即便以后
高出H 也永久不能居住。

2.若一个岛出现时在水底下，它将不被计入总数

同时居民会对cxw123 做出以下询问：
1.询问到现在累计有多少岛屿无法居住。
2.询问现在可居住岛屿中，距离海平面第k 高的岛屿高度是多少。
Cxw123 的地理经常考崩，请问你能帮助他解决这个问题吗？

输入数据：
第1 行为两个整数n、H，代表日志与询问共有n 行，要求高度为H（见题干）
第2 行至第n+1 行为日志与询问的具体内容：
C a 表示有一个现在距离海平面高度为a 的岛屿生长出来。
U b 表示海平面上升b。
D c 表示海平面下降c。

Q 询问到现在累计有多少岛屿无法居住。输出一行一个整数。
K d 询问现在可居住岛屿中，距离海平面第d 高的岛屿高度是多少。输出一行一个整数。
若d 大于当前可居住岛屿数量，输出-1。
请注意，每一行并不一定为有意义的日志或询问，但保证无意义的一行首字符为.(英文句号)。
输出数据：
m 行，每行一个整数，m 为询问次数。

样例输入和输出：
样例输入1：

12 10
C 60
C 70
Q
U 50
K 2
C 30
U 15
Q
D 5
K 1
K 2
Q

样例输出1：

0
10
2
20
-1
2

数据范围：

（大写字母代表该情况出现次数，小写字母含义见输入数据栏）

对于20%的数据:C<=1000; U+D<=10; K<=1000; b,c<=100; a<=500

对于50%的数据:C<=10000; U+D<=20; K<=10000; b,c<=500; a<=5000

对于80%的数据:C<=100000; U+D<=50; K<=100000; b,c<=1000; a<=10000

对于100%的数据:C<=500000; U+D<=200; K<=500000; b,c<=2000; a<=100000

Solution:

dasxxx出的毒瘤题目！[NOI2004]郁闷的出纳员改编题。

首先抓住这么多操作一定是一个数据结构的题目。

而数据范围当中U和D的范围都那么小说明对于U和D操作可以稍微暴力一些。

稍微看下题目我们会发现一个明显的K操作：求K大，好了是平衡树了！

但是一个U和D操作影响Treap中的元素（其实只有U操作），而对于每一个U和D操作暴力在Treap找出所有元素的复杂度太大无法接受，

于是我们想到在外部增加一个记录海水增量的变量xrr，上涨的时候+x，下降的时候-x。

而塞入Treap中的是它的绝对高度H'（相对高度）+xrr（海水的增量高度），输出的时候-xrr就是相对高度就行。

这里举个例子比方说当前海水增量为1，加入一个相对高度为5的岛屿，存入6，下次海水上升1（变成2），输出的时候就是6-2=4就行。

所以只要在外面处理海水增量的问题。

考虑到找Treap中的最小值比较麻烦，在初始化的时候我们自动加入一个inf和一个-inf，这样找最大就是pre(inf-1)，最小就是nex(-inf+1)

比较方便。

依次讲讲每个操作吧：

'.'：略过

‘C a’：判断a有没有满过H如果没有，弹出，否则将a+xrr塞入Treap。

‘U b’：将xrr+=b，然后暴力一直寻找高度最小值，判断其相对高度（Treap中存的数-xrr）是否在H以下，是弹出Treap，Ans++，否则不继续循环。

‘D c’：xrr-=c

‘Q’：输出Ans

‘K d’：首先判-1（Treap中元素Size()小于d无解），然后由于是求最大，直接求Size()-d+1小即可。

然后不要忘记输入输出优化！这样的话可以加快不被卡！

# include <bits/stdc++.h>
# define inf (0x7f7f7f7f7f)
# pragma G++ optimze()
using namespace std;
const int N=;
char s[];
char tb[];
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
inline char gd(){
    char c=getchar();
    while(c!='U'&&c!='D'&&c!='K'&&c!='Q'&&c!='C'&&c!='.')c=getchar();
    return c;
}
inline void write(int x)
{
    if (x>) write(x/);
    putchar(''+x%);
}
inline void writeln(int x)
{
    if (x<) cout<<x<<'\n';
    write(x); putchar('\n');
}
struct Treap{
#define L (t[x].ch[0])
#define R (t[x].ch[1])
#define V (t[x].v)
    struct node{int ch[],v,size,cnt,key;}t[N];
    int tot,root;
    void update(int x){t[x].size=t[L].size+t[R].size+t[x].cnt;}
    Treap(){
        tot=;
        _insert(root,-inf);
        _insert(root,inf);
        update(root);
    }
    void rotate(int &x,int d)
    {
        int son=t[x].ch[d];
        t[x].ch[d]=t[son].ch[d^];
        t[son].ch[d^]=x;
        update(x);update(x=son);
    }
    void insert(int val){_insert(root,val);}
    void _insert(int &x,int val)
    {
        if (!x) {
            x=++tot;
            t[x].size=t[x].cnt=;
            t[x].v=val;
            t[x].key=rand();
            return;
        }
        t[x].size++;
        if (V==val) {t[x].cnt++;return;}
        int d=V<val;
        _insert(t[x].ch[d],val);
        if (t[x].key>t[t[x].ch[d]].key) rotate(x,d);
    }
    void erase(int val){
        _erase(root,val);
    }
    void _erase(int &x,int val)
    {
        if (!x) return;
        if (V==val) {
            if (t[x].cnt>) { t[x].size--;t[x].cnt--; return;}
            int d=t[L].key>t[R].key;
            if (L==||R==) x=L+R;
            else rotate(x,d),_erase(x,val);
        } else {
            t[x].size--;
            int d=V<val;
            _erase(t[x].ch[d],val);
        }
    }
    int _rank(int x,int val)
    {
        if (!x) return ;
        if (V==val) return t[L].size+;
        if (V<val) return t[L].size+t[x].cnt+_rank(R,val);
        if (V>val) return _rank(L,val);
    }
    int rank(int val) { return _rank(root,val)-;}
    int _find(int x,int rank)
    {
        if (!x) return inf;
        if (t[L].size>=rank) return _find(L,rank);
        if (t[L].size+t[x].cnt>=rank) return t[x].v;
        return _find(R,rank-t[L].size-t[x].cnt);
    }
    int find(int rank){return _find(root,rank+);}
    int pre(int x,int val)
    {
        if (!x) return -inf;
        if (t[x].v>=val) return pre(L,val);
        return max(pre(R,val),t[x].v);
    }
    int nex(int x,int val)
    {
        if (!x) return inf;
        if (t[x].v<=val) return nex(R,val);
        return min(nex(L,val),t[x].v);
    }
    int Size(){ return t[root].size-;}
    int getMin(){return nex(root,-inf+);}
    int getMax(){return pre(root,inf-);}
}treap;
int main()
{
    srand(time(NULL)*);
    int xrr=,Ans=,T,H; cin>>T>>H;
    while (T--) {
        char op=gd(); int x;
        if (op=='C') {
            x=read(); if (x<H) continue;
            treap.insert(x+xrr);
        }
        else if (op=='U') {
            x=read(); xrr+=x;
            int t;
            while((t=treap.getMin())-xrr<H)
                treap.erase(t),Ans++;
        }
        else if (op=='D') { x=read(),xrr-=x;}
        else if (op=='Q') { writeln(Ans); }
        else if (op=='K') {
            int t,t2; t=read();
            if ((t2=treap.Size())<t) {
                puts("-1"); continue;
            }
            writeln(treap.find(t2-t+)-xrr);
        }
        else {gets(tb);}
    }
    return ;
}

P1486 [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

Solution:

I操作就是C操作：

A操作就是D操作：

S操作就是U操作：

F操作就是K操作：

最后输出的一个就是Q操作：

几乎一模一样！

# include <bits/stdc++.h>
# define inf (0x7f7f7f7f7f)
# pragma G++ optimze()
using namespace std;
const int N=;
char s[];
char tb[];
inline int read()
{
    int X=,w=; char c=;
    while(c<''||c>'') {w|=c=='-';c=getchar();}
    while(c>=''&&c<='') X=(X<<)+(X<<)+(c^),c=getchar();
    return w?-X:X;
}
inline char gd(){
    char c=getchar();
    while(c!='I'&&c!='A'&&c!='S'&&c!='F')c=getchar();
    return c;
}
inline void write(int x)
{
    if (x>) write(x/);
    putchar(''+x%);
}
inline void writeln(int x)
{
    if (x<) cout<<x<<'\n';
    write(x); putchar('\n');
}
struct Treap{
#define L (t[x].ch[0])
#define R (t[x].ch[1])
#define V (t[x].v)
    struct node{int ch[],v,size,cnt,key;}t[N];
    int tot,root;
    void update(int x){t[x].size=t[L].size+t[R].size+t[x].cnt;}
    Treap(){
        tot=;
        _insert(root,-inf);
        _insert(root,inf);
        update(root);
    }
    void rotate(int &x,int d)
    {
        int son=t[x].ch[d];
        t[x].ch[d]=t[son].ch[d^];
        t[son].ch[d^]=x;
        update(x);update(x=son);
    }
    void insert(int val){_insert(root,val);}
    void _insert(int &x,int val)
    {
        if (!x) {
            x=++tot;
            t[x].size=t[x].cnt=;
            t[x].v=val;
            t[x].key=rand();
            return;
        }
        t[x].size++;
        if (V==val) {t[x].cnt++;return;}
        int d=V<val;
        _insert(t[x].ch[d],val);
        if (t[x].key>t[t[x].ch[d]].key) rotate(x,d);
    }
    void erase(int val){
        _erase(root,val);
    }
    void _erase(int &x,int val)
    {
        if (!x) return;
        if (V==val) {
            if (t[x].cnt>) { t[x].size--;t[x].cnt--; return;}
            int d=t[L].key>t[R].key;
            if (L==||R==) x=L+R;
            else rotate(x,d),_erase(x,val);
        } else {
            t[x].size--;
            int d=V<val;
            _erase(t[x].ch[d],val);
        }
    }
    int _rank(int x,int val)
    {
        if (!x) return ;
        if (V==val) return t[L].size+;
        if (V<val) return t[L].size+t[x].cnt+_rank(R,val);
        if (V>val) return _rank(L,val);
    }
    int rank(int val) { return _rank(root,val)-;}
    int _find(int x,int rank)
    {
        if (!x) return inf;
        if (t[L].size>=rank) return _find(L,rank);
        if (t[L].size+t[x].cnt>=rank) return t[x].v;
        return _find(R,rank-t[L].size-t[x].cnt);
    }
    int find(int rank){return _find(root,rank+);}
    int pre(int x,int val)
    {
        if (!x) return -inf;
        if (t[x].v>=val) return pre(L,val);
        return max(pre(R,val),t[x].v);
    }
    int nex(int x,int val)
    {
        if (!x) return inf;
        if (t[x].v<=val) return nex(R,val);
        return min(nex(L,val),t[x].v);
    }
    int Size(){ return t[root].size-;}
    int getMin(){return nex(root,-inf+);}
    int getMax(){return pre(root,inf-);}
}treap;
int main()
{
    srand(time(NULL)*);
    int xrr=,Ans=,T,H; cin>>T>>H;
    while (T--) {
        char op=gd(); int x;
        if (op=='I') {
            x=read(); if (x<H) continue;
            treap.insert(x+xrr);
        }
        else if (op=='S') {
            x=read(); xrr+=x;
            int t;
            while((t=treap.getMin())-xrr<H)
                treap.erase(t),Ans++;
        }
        else if (op=='A') { x=read(),xrr-=x;}
        else if (op=='Q') { writeln(Ans); }
        else if (op=='F') {
            int t,t2; t=read();
            if ((t2=treap.Size())<t) {
                puts("-1"); continue;
            }
            writeln(treap.find(t2-t+)-xrr);
        }
        else {gets(tb);}
    }
    writeln(Ans);
    return ;
}