【bzoj3224】Tyvj 1728 普通平衡树

作大死的写了一发替罪羊树……
这也是很久的坑了……终于成功地写掉了替罪羊……
SGT这东西挺神奇的，相对于某疯狂旋转的splay来说挺暴力的（好像两个平衡树都是奇怪的暴力？）
判断某结点是否是替罪羊借鉴了某神犇的code
不过好像也就这么写的嘛。。。
对于某个节点，如果左子树或者右子树的size大于这个子树的size*alpha，这个节点就是替罪羊
然后要注意mark，cnt和size的意义、维护
mark标记这个点的权值有多少个，因为SGT是不会真正地删掉某个点的，只是把某个点标记为已删除，那么在insert和remove的时候，如果对应的权值节点存在的话，就把这个节点的mark值更改
size是平衡树里面这个节点的子树下有多少个节点
cnt是这个节点的子树下有多少个实际的权值，也就是mark值的和

insert的时候注意重复节点，mark、cnt和size的信息要维护好
remove的时候找到了某个点mark–之后，要从这个点一直到根都mainain一次
查某数rank就用cnt，注意一个点上可能有多个实际权值，要处理好mark的信息
查K大也要注意最后实际上是一个范围 k∈[cntlc+1,cntlc+marku]
查前驱后继的话没有想到更好的办法，就记录了子树的最大最小值，然后一路跑下去，更新答案。

好像细节还是挺多的……写了两天……太弱不解释T_T

#include <bits/stdc++.h>
#define maxn 150007
#define lc ch[u][0]
#define rc ch[u][1]

const int inf = 0x7fffffff;

inline void upmin(int&a , int b) { if (a > b) a = b ; }
inline void upmax(int&a , int b) { if (a < b) a = b ; }

inline int rd() {
    char c = getchar() ; int x = 0 , f = 1;
    while (!isdigit(c) && c != '-') c = getchar();
    if (c == '-') f = -1 ; else x = c - '0';
    while (isdigit(c = getchar())) x = x * 10 + c - '0';
    return x * f;
}

typedef int arr[maxn];

arr cnt , val , size , fa , mark , a , mx , mn , times;
int ch[maxn][2] , tot ,  node_tot , rt;
double alpha;

bool sgt(int u) {
    return size[lc] > alpha * size[u] + 3 || size[rc] > alpha * size[u] + 3;
}

void maintain(int u) {
    cnt[u] = mark[u] , size[u] = 1;
    if (mark[u]) mx[u] = mn[u] = val[u];
    else mx[u] = -(mn[u] = inf);
    if (lc) cnt[u] += cnt[lc] , size[u] += size[lc] , fa[lc] = u , upmax(mx[u] , mx[lc]) , upmin(mn[u] , mn[lc]);
    if (rc) cnt[u] += cnt[rc] , size[u] += size[rc] , fa[rc] = u , upmax(mx[u] , mx[rc]) , upmin(mn[u] , mn[rc]);
}

int insert(int&u , int v) {
    if (!u) {
        u = ++ node_tot;
        mx[u] = mn[u] = val[u] = v , cnt[u] = size[u] = mark[u] = 1;
        return 0;
    }
    cnt[u] ++ , size[u] ++;
    upmax(mx[u] , v) , upmin(mn[u] , v);
    if (v == val[u])
        { size[u] -- , mark[u] ++ ; return 0; }
    int ret = 0;
    int d = (v >= val[u]);
    ret = insert(ch[u][d] , v) , fa[ch[u][d]] = u;
    if (sgt(u)) ret = u;
    return ret;
}

void travel(int u) {
    if (!u) return;
    travel(lc);
    if (mark[u]) a[++ tot] = val[u] , times[tot] = mark[u];
    travel(rc);
}

void build(int&u , int l , int r) {
    if (l > r) return;
    u = ++ node_tot;
    int m = (l + r) >> 1;
    val[u] = a[m] , mark[u] = times[m];
    build(lc , l , m - 1) , build(rc , m + 1 , r);
    maintain(u);
}

void rebuild(int u) {
    int f = fa[u] , d = (ch[f][1] == u);
    tot = 0 , travel(u);
    build(u , 1 , tot) ;
    if (!f) 
        { rt = u ; return ; }
    for(fa[u] = f , ch[f][d] = u;f;f = fa[f]) maintain(f);
}

void insert_x(int u) {
    u = insert(rt ,  u);
    if (u) rebuild(u);
}

int find(int u , int v) {
    while (u && (val[u] != v || !mark[u])) u = ch[u][v >= val[u]];
    return u;
}

void remove_x(int u) {
    u = find(rt , u) ;
    if (!u) return ;
    for(mark[u] --;u;u = fa[u]) maintain(u);
}

void get_rank(int u) {
    int v = u , ret = 0;u = rt;
    while (1) {
        if (v >= val[u]) {
            ret += cnt[lc] + 1;
            if (mark[u] && v == val[u]) break;
            ret += mark[u] - 1;
            u = rc;
        }
        else u = lc;
    }
    printf("%d\n" , ret);
}

void order_of(int x) {
    int u = rt;
    while (1) {
        if (!mark[u]) {
            if (cnt[lc] >= x) u = lc ; else x -= cnt[lc] , u = rc;
        } else {
            if (cnt[lc] + mark[u] >= x && cnt[lc] + 1 <= x) break;
            if (cnt[lc] + mark[u] >  x) u = lc ; else x -= cnt[lc] + mark[u] , u = rc;
        }
    }
    printf("%d\n" , val[u]);
}

void get_pref(int u) {
    int v = u , ret = 0 ; u = rt ;
    while (u) {
        if (v > val[u]) {
            upmax(ret , mx[lc]);
            if (mark[u]) upmax(ret , val[u]);
            u = rc;
        }
        else u = lc;
    }
    printf("%d\n" , ret);
}

void get_succ(int u) {
    int v = u , ret = mx[rt] ; u = rt ;
    while (u) {
        if (v < val[u]) {
            upmin(ret , mn[rc]);
            if (mark[u]) upmin(ret , val[u]);
            u = lc;
        }
        else u = rc;
    }
    printf("%d\n" , ret);
}

int main() {
    #ifndef ONLINE_JUDGE
        freopen("data.txt" , "r" , stdin);
        freopen("data.out" , "w" , stdout);
    #endif 
    alpha = 0.542;
    mx[0] = - (mn[0] = inf);
    for(int i = rd() , opt , x ; i ; i --) {
        assert(!fa[rt]);
        opt = rd() , x = rd();
        if (opt == 1) insert_x(x);
        else if (opt == 2) remove_x(x);
        else if (opt == 3) get_rank(x);
        else if (opt == 4) order_of(x);
        else if (opt == 5) get_pref(x);
        else if (opt == 6) get_succ(x);
    }
    return 0;
}