• 【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(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<<'
    ';
        write(x); putchar('
    ');
    }
    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<<'
    ';
        write(x); putchar('
    ');
    }
    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;
    }
  • 相关阅读:
    【javascript基础】【转】各浏览器对页面外部资源加载的策略
    【javascript基础】【转】javascript模块化、模块加载器初探
    【javascript基础】js线程机制【转】
    【css】【转】那些年我们一起清除过的浮动
    IL入门之旅(三)——Dump对象
    学习TPL(一)
    弱引用应用的注意点
    IL入门之旅(二)——动态包装
    学习TPL(二)
    IL之旅(前言)
  • 原文地址:https://www.cnblogs.com/ljc20020730/p/10337107.html
Copyright © 2020-2023  润新知