Splay 夏大神版

struct Splay{
    struct obj{
        int s,v,cnt;
        obj*f,*c[2];
        obj(int _v=0,int _cnt=0,obj*_f=null):
            v(_v),cnt(_cnt),f(_f){c[0]=c[1]=null;}
        void gets(){
            s=size(c[0])+cnt+size(c[1]);
        }
    }*root;
 
    void rotate(obj*x){
        obj*y=x->f;
        if(y==null)return;
        int d=x==y->c[0];
        y->c[!d]=x->c[d];
        if(x->c[d])x->c[d]->f=y;
        x->f=y->f;
        if(y->f)y->f->c[y==y->f->c[1]]=x;
        y->f=x,x->c[d]=y;
        y->gets(),x->gets();
        if(y==root)root=x;
    }
 
    void splay(obj*x,obj*f){
        while(x->f!=f){
            if(x->f->f==f) rotate(x);
            else rotate(((x->f->f->v>x->f->v)^(x->f->v>x->v))?x:x->f),rotate(x);
        }
        x->gets();
    }
 
    void insert(int v){
        if(root==null){
            root=new obj(v,1,null);
            return;
        }
        obj*x=root,*y=null;
        while(x&&x->v!=v)y=x,x=x->c[v>x->v];
        if(x){
            x->cnt++;
            splay(x,null);
        }else{
            x=new obj(v,1,y);
            if(y)y->c[v>y->v]=x;
            splay(x,null);
        }
    }
 
    void del(int v){
        obj*x=root;
        while(x&&x->v!=v)x=x->c[v>x->v];
        if(x==null)return;
        else if(x->cnt>1){
            x->cnt--;
            splay(x,null);
            return;
        }
        splay(x,null);
        if(x->c[0]){
            x=x->c[0];
            while(x->c[1])x=x->c[1];
            splay(x,root);
            x->f=null,x->c[1]=root->c[1];
            if(root->c[1])root->c[1]->f=x;
            swap(x,root);
            delete x;
        }else{
            x=x->c[1];
            if(x)x->f=null;
            swap(x,root);
            delete x;
        }
    }
 
    void display(obj*root){
        if(!root)return;
        display(root->c[0]);
        printf("%d ",root->v);
        display(root->c[1]);
    }
 
    obj*kth(int k){
        for(obj*x=root;x;){
            if(size(x->c[0])+1==k)return x;
            else if(size(x->c[0])>=k)x=x->c[0];
            else k-=size(x->c[0])+1,x=x->c[1];
        }
    }
 
    void clean(obj*x){
        if(x==null)return;
        clean(x->c[0]),clean(x->c[1]);
        delete x;
    }
 
    int next(int v){
        int ans=INF;
        for(obj*x=root;x;){
            if(x->v>v)ans=min(ans,x->v),x=x->c[0];
            else x=x->c[1];
        }
        return ans;
    }
 
    int prev(int v){
        int ans=-INF;
        for(obj*x=root;x;){
            if(x->v<v)ans=max(ans,x->v),x=x->c[1];
            else x=x->c[0];
        }
        return ans;
    }
 
    int knum(int v){
        obj*x=root;
        while(x&&x->v!=v)x=x->c[v>x->v];
        if(x)return x->cnt;
        else return 0;
    }
 
    int rank(int v){
        obj*x=root;
        int ans=0;
        while(x&&x->v!=v){
            if(x->v<v) ans+=size(x->c[0])+x->cnt,x=x->c[1];
            else x=x->c[0];
        }
        return ans+(x?size(x->c[0]):0);
    }
 
    void init(){clean(root);root=null;}
    Splay(){root=null;}
    ~Splay(){clean(root);root=null;}
};
 
int l[maxn],r[maxn],ls[maxn],rs[maxn],mid[maxn],lotree;
Splay data[maxn];
int build(int _l, int _r){
    int root=lotree++;
    l[root]=_l,r[root]=_r,mid[root]=(_l+_r)/2,data[root].init();
    if(_l!=_r)ls[root]=build(_l,mid[root]),rs[root]=build(mid[root]+1,_r);
    else ls[root]=-1,rs[root]=-1;
    return root;
}
 
int arr[maxn];
void add(int root,int pos, int _data){
    if(root==-1)return;
    data[root].insert(_data);
    if (pos<=mid[root])add(ls[root],pos,_data);
    else add(rs[root],pos,_data);
}
 
void modify(int root,int pos,int _data){
    if(root==-1)return;
    data[root].del(arr[pos]);
    data[root].insert(_data);
    if (pos<=mid[root])modify(ls[root],pos,_data);
    else modify(rs[root],pos,_data);
}
 
int next(int root, int _l, int _r, int v){
    _l=max(_l,l[root]),_r=min(_r,r[root]);
    if(_l>_r)return INF;
    if(_l==l[root]&&_r==r[root])return data[root].next(v);
    else return min(next(ls[root],_l,_r,v),next(rs[root],_l,_r,v));
}
 
int prev(int root, int _l, int _r, int v){
    _l=max(_l,l[root]),_r=min(_r,r[root]);
    if(_l>_r)return -INF;
    if(_l==l[root]&&_r==r[root])return data[root].prev(v);
    else return max(prev(ls[root],_l,_r,v),prev(rs[root],_l,_r,v));
}
 
int rank(int root,int _l,int _r,int k){
    _l=max(_l,l[root]),_r=min(_r,r[root]);
    if(_l>_r)return 0;
    if(_l==l[root]&&_r==r[root])return data[root].rank(k);
    else return rank(ls[root],_l,_r,k)+rank(rs[root],_l,_r,k);
}
 
int knum(int root,int _l,int _r,int k){
    _l=max(_l,l[root]),_r=min(_r,r[root]);
    if(_l>_r)return 0;
    if(_l==l[root]&&_r==r[root])return data[root].knum(k);
    else return knum(ls[root],_l,_r,k)+knum(rs[root],_l,_r,k);
}
 
int kth(int root,int _l,int _r,int k){
    int head=0,tail=100000001;
    while(tail-head>1){
        int mid=(head+tail)/2;
        if (rank(root, _l,_r,mid)<k)head=mid;
        else tail=mid;
    }
    return head;
}
 
int main()
{
    //FF;
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        lotree=0;
        int root=build(1,n);
        for(int i=1;i<=n;i++)scanf("%d",arr+i),add(root,i,arr[i]);
        while(m--){
            int o,t1,t2,t3;
            scanf("%d",&o);
            switch(o){
            case 1:
                scanf("%d%d%d",&t1,&t2,&t3);
                printf("%d\n",rank(root,t1,t2,t3)+1);
                break;
            case 2:
                scanf("%d%d%d",&t1,&t2,&t3);
                printf("%d\n",kth(root,t1,t2,t3));
                break;
            case 3:
                scanf("%d%d",&t1,&t2);
                modify(root,t1,t2);
                arr[t1]=t2;
                break;
            case 4:
                scanf("%d%d%d",&t1,&t2,&t3);
                printf("%d\n",prev(root,t1,t2,t3));
                break;
            case 5:
                scanf("%d%d%d",&t1,&t2,&t3);
                printf("%d\n",next(root,t1,t2,t3));
                break;
            }
        }
    }
}