zoj 2112 Dynamic Rankings(SBT in SegTree)

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1112

　　这题以前我曾经是用k大数DC搜过去的，每次k大前都复制区间，理论上那是必然超时的。今天我用线段树套SBT过了这题，不过其实用树套树做，最后还是要二分结果区间来得到最终的结果，复杂度是O(nlognlogn)。最近看了可持续化数据结构的论文，这题用可持续化线段树可以使代码更简单，内存消耗更小，虽然复杂度貌似没有变。

　　这题建立多棵平衡树以后，在使用完以后必须销毁，不然会MLE的！

代码如下：

#include <cstdio>
#include <cstdlib>
#include <algorithm>

using namespace std;

const int inf = 0x7f7f7f7f;
const int maxn = 50001;
struct SBTNode {
    int size, key;
    SBTNode *c[2];

    SBTNode(int k = 0) {
        key = k;
        size = 1;
        c[0] = c[1] = NULL;
    }
} ;
struct SBTree {
    SBTNode *Root;

    SBTree() {
        Root = NULL;
    }

    void delTreeMain(SBTNode *&rt) {
        if (!rt) return ;
        delTreeMain(rt->c[0]);
        delTreeMain(rt->c[1]);
        delete rt;
        rt = NULL;
    }

    void delTree() {
        delTreeMain(Root);
    }

    void rotate(SBTNode *&x, bool left) {
        bool right = !left;
        SBTNode *y = x->c[left];

        x->c[left] = y->c[right];
        y->c[right] = x;
        y->size = x->size;

        x->size = (x->c[0] ? x->c[0]->size : 0) + (x->c[1] ? x->c[1]->size : 0) + 1;
        x = y;
    }

    int getPosMain(int key, SBTNode *rt) {
        if (!rt) return 0;

        int k = rt->key;

//        if (key == k) return rt->c[0] ? rt->c[0]->size : 0;
        if (key <= k) return getPosMain(key, rt->c[0]);
        else return getPosMain(key, rt->c[1]) + (rt->c[0] ? rt->c[0]->size : 0) + 1;
    }

    int getPos(int key) {
        return getPosMain(key, Root);
    }

    void maintain(SBTNode *&rt, bool right) {
        if (!rt->c[right] || !rt) return ;

        bool left = !right;
        int ls = rt->c[left] ? rt->c[left]->size : 0;

        if (rt->c[right]->c[right] && rt->c[right]->c[right]->size > ls) {
            rotate(rt, right);
        } else if (rt->c[right]->c[left] && rt->c[right]->c[left]->size > ls) {
            rotate(rt->c[right], left);
            rotate(rt, right);
        } else return ;

        maintain(rt->c[0], false);
        maintain(rt->c[1], true);
        maintain(rt, false);
        maintain(rt, true);
    }

    void insMain(SBTNode *&rt, SBTNode *x) {
        if (!rt) {
            rt = x;
            return ;
        }
        rt->size++;
        if (x->key < rt->key) insMain(rt->c[0], x);
        else insMain(rt->c[1], x);
        maintain(rt, x->key >= rt->key);
    }

    void ins(SBTNode *x) {
        insMain(Root, x);
    }

    void ins(int x) {
        SBTNode *tmp = new SBTNode(x);

        insMain(Root, tmp);
    }

    void delMain(SBTNode *&rt, int key) {
        if (!rt) return ;
        rt->size--;
        if (key < rt->key) {
            delMain(rt->c[0], key);
        } else if (key > rt->key) {
            delMain(rt->c[1], key);
        } else {
            SBTNode *t;

            if (!rt->c[0] && !rt->c[1]) {
                delete rt;
                rt = NULL;
            } else if (!rt->c[1]) {
                t = rt;
                rt = rt->c[0];
                delete t;
            } else if (!rt->c[0]) {
                t = rt;
                rt = rt->c[1];
                delete t;
            } else {
                t = rt->c[1];
                while (t->c[0]) t = t->c[0];
                rt->key = t->key;
                delMain(rt->c[1], t->key);
            }
        }
    }

    void del(int k) {
        delMain(Root, k);
    }

    void printMain(SBTNode *rt) {
        if (!rt) return ;
        printMain(rt->c[0]);
        printf("%d ", rt->key);
        printMain(rt->c[1]);
    }

    void print() {
        printMain(Root);
        puts("~~~");
    }
} sbt[maxn << 2];

int rec[maxn];
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1

void build(int l, int r, int rt) {
    sbt[rt] = SBTree();
    if (l == r) {
        return ;
    }
    int m = (l + r) >> 1;

    build(lson);
    build(rson);
}

void unbuild(int l, int r, int rt) {
    sbt[rt].delTree();
    if (l == r) {
        return ;
    }
    int m = (l + r) >> 1;

    unbuild(lson);
    unbuild(rson);
}

void ins(int pos, int key, int l, int r, int rt) {
    sbt[rt].ins(key);
    if (l == r) {
        return ;
    }
    int m = (l + r) >> 1;

    if (pos <= m) {
        ins(pos, key, lson);
    } else {
        ins(pos, key, rson);
    }
}

void repMain(int pos, int key, int l, int r, int rt) {
    sbt[rt].del(rec[pos]);
    sbt[rt].ins(key);
    if (l == r) {
        return ;
    }
    int m = (l + r) >> 1;

    if (pos <= m) {
        repMain(pos, key, lson);
    } else {
        repMain(pos, key, rson);
    }
}

void rep(int pos, int key, int N) {
    repMain(pos, key, 1, N, 1);
    rec[pos] = key;
}

int count(int key, int L, int R, int l, int r, int rt) {
    if (L <= l && r <= R) {
        return sbt[rt].getPos(key);
    }
    int m = (l + r) >> 1;
    int ret = 0;

    if (L <= m) ret += count(key, L, R, lson);
    if (m < R) ret += count(key, L, R, rson);

    return ret;
}

int DC(int L, int R, int N, int k) {
    int low = -1, high = 1000000001;
    int m;

    while (low + 1 < high) {
        m = (low + high) >> 1;
        if (count(m, L, R, 1, N, 1) < k) low = m;
        else high = m;
    }

    return low;
}

int main() {
    int T, n, m;
    int a, b, c;
    char buf[3];

//    freopen("in", "r", stdin);
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);
        build(1, n, 1);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &rec[i]);
            ins(i, rec[i], 1, n, 1);
        }
//        printf("?? %d\n", count(2, 1, 3, 1, n, 1));
        while (m--) {
            scanf("%s", buf);
            if (buf[0] == 'Q') {
                scanf("%d%d%d", &a, &b, &c);
                printf("%d\n", DC(a, b, n, c));
            } else {
                scanf("%d%d", &a, &b);
                rep(a, b, n);
            }
        }
        unbuild(1, n, 1);
    }
    /**** test SBTree ****
        sbt[0] = SBTree();
        for (int i = 0; i < 10; i++) {
            scanf("%d", &x);
            sbt[0].ins(x);
    //        sbt[0].print();
    //        puts("yeah~");
        }
        sbt[0].print();
        for (int i = 0; i < 5; i++) {
            scanf("%d", &x);
            printf("%d\n", sbt[0].getPos(x));
        }
        for (int i = 0; i < 3; i++) {
            scanf("%d", &x);
            sbt[0].del(x);
            sbt[0].print();
        }
    **********************/

    return 0;
}

——written by Lyon