玲珑1117RE：从零开始的异世界生活（线段树+思路）

1117 - RE：从零开始的异世界生活

Time Limit：1s Memory Limit：256MByte

Submissions：431Solved：66

DESCRIPTION

486到了异世界，看到了一群可爱的妹子比如蕾姆啊，艾米莉亚啊，拉姆啊，白鲸啊，怠惰啊等等!
有一天膜女告诉486说她的能力可能不能再用了，因为膜女在思考一个数据结构题，没心情管486了。
486说我来帮你做，膜女说你很棒棒哦！

给一个集合，最开始为空（不是数学上的集合）
五个操作：

1、插入x
2、把小于x的数变成x
3、把大于x的数变成x
4、求集合中第x小数
5、求集合中小于x的数个数

INPUT

第一行一个数m后面有m行，每行格式为opt x，opt表示是什么操作，x表示操作的值

OUTPUT

对于每个4,5操作，输出一个值表示答案

SAMPLE INPUT

51 11 34 12 334 1

SAMPLE OUTPUT

133

HINT

m <= 100000 , x <= 1000000000

一共有5种操作，数据给的很大，需要离散化，因此需要先把操作和数存起来，离散化后再做处理（对于操作4的数不要离散化）

对于每种操作

1：在离散化后x对应的位置+1

2：查找1~x-1之间有cnt个数，在x位置+cnt，更新1~x-1为0

3： 查找x+1~n之间有cnt个数，在x位置+cnt，更新x+1~n为0

4：二分1~n区间，寻找右端点

5：查找1~x-1之间有cnt个数

#include<bits/stdc++.h>
#define ll rt<<1
#define rr rt<<1|1
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
const int N=1e6+10;
struct data
{
    int op,x;
} e[N];
struct node
{
    int cnt,lazy,le,ri;
    int mid()
    {
        return (le+ri)>>1;
    }
} t[N<<2];
int p[N];
void build(int l,int r,int rt)
{
    t[rt].cnt=0,t[rt].lazy=-1,t[rt].le=l,t[rt].ri=r;
    if(l==r)return;
    int m=t[rt].mid();
    build(l,m,ll);
    build(m+1,r,rr);
}
void pushdown(int rt)
{
        t[ll].cnt=0;
        t[rr].cnt=0;
        t[ll].lazy=0;
        t[rr].lazy=0;
        t[rt].lazy=-1;
}
void update(int rt,int le,int ri,int val,int op)
{
    if(le<=t[rt].le&&t[rt].ri<=ri)
    {
        if(op==1)
            t[rt].cnt+=val;
        else
        {
            t[rt].lazy=0;
            t[rt].cnt=0;
        }
        return ;
    }
    if(t[rt].lazy!=-1)
        pushdown(rt);
    int mid=t[rt].mid();
    if(le<=mid)
        update(ll,le,ri,val,op);
    if(ri>mid)
        update(rr,le,ri,val,op);
    t[rt].cnt=t[ll].cnt+t[rr].cnt;
}
int query(int rt,int le,int ri)
{
    if(le<=t[rt].le&&t[rt].ri<=ri)return t[rt].cnt;
    if(t[rt].lazy!=-1)
    pushdown(rt);
    int m=t[rt].mid(),res=0;
    if(le<=m)res+=query(ll,le,ri);
    if(ri>m)res+=query(rr,le,ri);
     t[rt].cnt=t[ll].cnt+t[rr].cnt;
    return res;
}
int main()
{
    int tot=0,m,x,y;
    scanf("%d",&m);
    for(int i=1; i<=m; i++)
    {
        scanf("%d%d",&e[i].op,&e[i].x);
        if(e[i].op!=4)
            p[++tot]=e[i].x;
    }
    sort(p+1,p+tot+1);
    n=unique(p+1,p+1+tot)-(p+1);
    build(1,n,1);
    for(int i=1; i<=m; i++)
    {
        if(e[i].op==1)
        {
             x=lower_bound(p+1,p+1+n,e[i].x)-p;
            update(1,x,x,1,1);
        }
        else if(e[i].op==2)
        {
             x=lower_bound(p+1,p+1+n,e[i].x)-p;
            if(x>1)
            {
                 y=query(1,1,x-1);
                update(1,1,x-1,0,2);
                update(1,x,x,y,1);
            }
        }
        else if(e[i].op==3)
        {
             x=lower_bound(p+1,p+1+n,e[i].x)-p;
            if(x<n)
            {
                 y=query(1,x+1,n);
                update(1,x+1,n,0,2);
                update(1,x,x,y,1);
            }
        }
        else if(e[i].op==4)
        {
            int mid,l=1,r=n,ans;
            x=e[i].x;
            while(l<=r)
            {
                 mid=(l+r)>>1;
                if(x<=query(1,1,mid))
                {
                    ans=mid;
                    r=mid-1;
                }
                else
                {
                    l=mid+1;
                }
            }
            printf("%d\n",p[ans]);
        }
        else
        {
             x=lower_bound(p+1,p+1+n,e[i].x)-p;
            printf("%d\n",query(1,1,x-1));
        }
    }
return 0;
}