无旋treap（可持久化）

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
using namespace std;
const int MAXN=2000000+10;
struct NODE{//小根堆treap 
    NODE *ch[2];
    int v,r,s;
    #define size(x) ((x)?(x)->s:0)
    NODE(int v=0):v(v){r=rand();ch[0]=ch[1]=NULL;s=1;}
    bool operator < (const NODE &rhs) const {
        return r < rhs.r;
    }
    int cmp(int x){
        if(x == v) return -1;
        return x < v ? 0:1;
    }
    void mt(){
        s=1;
        s+=size(ch[0]);
        s+=size(ch[1]);
    }
}*root;
//无旋treap相关 
typedef pair<NODE*,NODE*> droot;
droot split(NODE *x,int k){
    if(x == NULL) return droot(NULL,NULL);
    droot r;
    if(size(x->ch[0]) >= k){
        r=split(x->ch[0],k);
        x->ch[0]=r.second;
        x->mt();
        r.second=x;
    }
    else {
        r=split(x->ch[1],k-size(x->ch[0])-1);
        x->ch[1]=r.first;
        x->mt();
        r.first=x;
    }
    return r;
}
NODE *merge(NODE *a,NODE *b){
    if(a == NULL) return b;
    if(b == NULL) return a;
    if(a->r < b->r){
        a->ch[1]=merge(a->ch[1],b);
        a->mt();
        return a;
    }
    else {
        b->ch[0]=merge(a,b->ch[0]);
        b->mt();
        return b;
    }
}
NODE *build(int *a){//类似于笛卡尔树 
    static NODE *stack[MAXN],*x,*last;
    int p=0;
    for(int i=1;i<=a[0];i++){
        x=new NODE(a[i]);
        last=NULL;
        while(p && stack[p]->r > x->r){
            stack[p]->mt();
            last=stack[p];
            stack[p--]=NULL;
        }
        if(p) stack[p]->ch[1]=x;
        x->ch[0]=last;
        stack[++p]=x;
    }
    while(p) stack[p--]->mt();
    return stack[1];
}
//名次树相关
int rank(NODE *x,int v){
    if(x == NULL) return 0;
    if(v < x->v) return rank(x->ch[0],v);
    else rank(x->ch[1],v)+size(x->ch[0])+1;
} 
int kth(int k){
    droot x=split(root,k-1);
    droot y=split(x.second,1);
    NODE *ans=y.first;
    root=merge(merge(x.first,ans),y.second);
    return ans->v;
}
void insert(int v){
    int k=rank(root,v);
    droot x=split(root,k);
    NODE *n=new NODE(v);
    root=merge(merge(x.first,n),x.second);
}
void remove(int k){
    droot x=split(root,k-1);
    droot y=split(x.second,1);
    root=merge(x.first,y.second);
}

int a[MAXN],M,x,y;
 
int main(){
    freopen("bst.in","r",stdin);
    freopen("bst.out","w",stdout);
     
    scanf("%d",a);
    for(int i=1;i<=a[0];i++) scanf("%d",a+i);
    sort(a+1,a+1+a[0]);
    root=build(a);
     
    scanf("%d",&M);
    while(M--){
        char ch=getchar();
        while(ch!='Q' && ch!='A' && ch!='D') ch=getchar();
        scanf("%d",&x);
        if(ch=='Q') printf("%d
",kth(x));
        if(ch=='A') insert(x);
        if(ch=='D') remove(x);
    }
    return(0);
}