【Treap 例题】神秘岛（island）

傷城~ 2021-10-24 03:56 381阅读 0赞

> **神秘岛（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(2)
    using namespace std;
    const int N=1000010;
    char s[105];
    char tb[100005];
    inline int read()
    {
        int X=0,w=0; char c=0;
        while(c<'0'||c>'9') {w|=c=='-';c=getchar();}
        while(c>='0'&&c<='9') X=(X<<3)+(X<<1)+(c^48),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>9) write(x/10);
        putchar('0'+x%10);
    }
    inline void writeln(int x)
    {
        if (x<0) 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[2],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=2;
            _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^1];
            t[son].ch[d^1]=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=1;
                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>1) { t[x].size--;t[x].cnt--; return;}
                int d=t[L].key>t[R].key;
                if (L==0||R==0) 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 0;
            if (V==val) return t[L].size+1;
            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)-1;}
        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+1);}
        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-2;}
        int getMin(){
        return nex(root,-inf+1);}
        int getMax(){
        return pre(root,inf-1);}
    }treap;
    int main()
    {
        srand(time(NULL)*100007);
        int xrr=0,Ans=0,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+1)-xrr);
            }
            else {gets(tb);}
        }
        return 0;
    }

> # 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(2)
    using namespace std;
    const int N=1000010;
    char s[105];
    char tb[100005];
    inline int read()
    {
        int X=0,w=0; char c=0;
        while(c<'0'||c>'9') {w|=c=='-';c=getchar();}
        while(c>='0'&&c<='9') X=(X<<3)+(X<<1)+(c^48),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>9) write(x/10);
        putchar('0'+x%10);
    }
    inline void writeln(int x)
    {
        if (x<0) 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[2],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=2;
            _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^1];
            t[son].ch[d^1]=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=1;
                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>1) { t[x].size--;t[x].cnt--; return;}
                int d=t[L].key>t[R].key;
                if (L==0||R==0) 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 0;
            if (V==val) return t[L].size+1;
            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)-1;}
        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+1);}
        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-2;}
        int getMin(){
        return nex(root,-inf+1);}
        int getMax(){
        return pre(root,inf-1);}
    }treap;
    int main()
    {
        srand(time(NULL)*100007);
        int xrr=0,Ans=0,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+1)-xrr);
            }
            else {gets(tb);}
        }
        writeln(Ans);
        return 0;
    }

转载于:https://www.cnblogs.com/ljc20020730/p/10337107.html