[BZOJ4825][HNOI2017]单旋 平衡树

诶这题有一万种做法
按key值从小到大排序，对每一位维护他的深度
将一个点旋到根，相当于他所在的子树里的深度不变，剩余平衡树链接在这个点下面
用Treap维护这个序列
对于插入操作：查询key值的前驱和后继，取较大值+1作为改点的新深度
对于查询最小值操作：寻找序列第一个深度小于最小值所在节点的深度的那个点，这个点即为待旋节点的父亲，这个区间的深度不变，剩余区间的深度做区间加法，再特殊处理改点的深度
删除就将这个点删除，所有节点的深度减一
最大值同理

#include <iostream>
#include <cstdio>
#include <cstdlib>
#define N 100050

#define MP make_pair
#define x first
#define y second
#define O tr[t]
#define L tr[tr[t].l]
#define R tr[tr[t].r]
#define E return
#define I int

using namespace std;
typedef pair<I,I> pii;
void GP(I &a,I &b,pii p) {a=p.x,b=p.y;}

struct Node{I l,r,siz,key,a,dep,min,ag; }tr[N];
I up(I t) {
    O.siz = L.siz + R.siz + 1;
    O.min = O.dep;
    tr[t].l ? O.min = min(O.min, L.min) :0;
    tr[t].r ? O.min = min(O.min, R.min) :0;
    E t;
}
I T,rt,cnt,n,r1,r2,A,B,k,j,cmd;

I rd() {I r;scanf("%d",&r);E r;}

I calc(I t,I x) {
    if (!t) E 0;
    E x > tr[t].a ?
        L.siz + 1 + calc(tr[t].r, x):
        calc(tr[t].l, x);
}

void pd(I t) {
    if (tr[t].l) L.min += O.ag, L.dep += O.ag, L.ag += O.ag;
    if (tr[t].r) R.min += O.ag, R.dep += O.ag, R.ag += O.ag;
    O.ag = 0;
}
void add(I t,I k) { if (!t) E ;O.min += k, O.dep += k, O.ag += k; }

pii spl(I t,I k) {
    if (!k) E MP(0,t);
    if (k == O.siz) E MP(t,0);
    pd(t); int tmp;
    E L.siz + 1 <= k ? 
        ( GP(O.r, tmp, spl(O.r,k-L.siz-1)), up(t), MP(t,tmp) ):
        ( GP(tmp, O.l, spl(O.l,k))        , up(t), MP(tmp,t) );
}

I mer(I x,I y) {
    if (!x || !y) E x+y;
    pd(x), pd(y);
    E tr[x].key > tr[y].key ?
        ( tr[x].r = mer(tr[x].r, y), up(x) ):
        ( tr[y].l = mer(x, tr[y].l), up(y) );
}

I pre(I t,I k) {
    if (!t) E 0; pd(t);
    E min(R.min,O.dep)>k?
        pre(tr[t].l,k)+1+R.siz:pre(tr[t].r,k);
}

I suf(I t,I k) {
    if (!t) E 0; pd(t);
    E min(L.min,O.dep)>k ?
        suf(tr[t].r,k)+1+L.siz:suf(tr[t].l,k);
}

int main() {
    freopen("splay.in","r",stdin);
    freopen("splay.out","w",stdout);
    srand(19930726);
    tr[0].min=(1<<30);
    for (T=rd();T;T--){
        cmd=rd();
        if (cmd==1){
            int k=rd(),nd=1,p=calc(rt,k);
            GP(r1,r2,spl(rt,p));
            if (p){
                GP(r1,A,spl(r1,tr[r1].siz-1));
                nd=max(nd, tr[A].dep+1);
                r1=mer(r1,A);
            }
            if (p<n){
                GP(B,r2,spl(r2,1));
                nd=max(nd,tr[B].dep+1);
                r2=mer(B,r2);
            }
            tr[++cnt]=(Node){0,0,1,rand(),k,nd,nd,0};
            printf("%d\n",nd);
            rt = mer(mer(r1,cnt),r2);
            ++n;
            continue;
        }

        if (cmd==2||cmd==4){
            GP(j,rt,spl(rt,1));
            printf("%d\n",tr[j].dep);
            int p=suf(rt,tr[j].dep);
            GP(k,rt,spl(rt,p));

            add(rt,2-tr[rt].min);
            add(j,1-tr[j].min);

            rt=mer(mer(j,k),rt);
            if (cmd>3) GP(k,rt,spl(rt,1)),add(rt,-1),n--;
        }else{
            GP(rt,j,spl(rt,n-1));
            printf("%d\n",tr[j].dep);
            I p=pre(rt, tr[j].dep);
            GP(rt,k,spl(rt,n-p-1));

            add(rt,2-tr[rt].min);
            add(j,1-tr[j].min);

            rt=mer(mer(rt,k),j);
            if (cmd>3) GP(rt,k,spl(rt,n-1)),add(rt,-1),n--;
        }
    }
    return 0;
}