SGU 263. Towers

各种操作：

1. put x c:表示在第 x 列上增加 c 个积木(c>0)。
2. tput t x c:表示在塔 t 的第 x 列上增加 c 个积木(c>0)。
3. towers:询问共有几座塔。
4. cubes t:询问第 t 座塔共有几个积木。
5. length t:询问第 t 座塔的长度。
6. tcubes t x:询问第 t 座塔的第 x 列有几个积木。

对应做法：

1. towers: 由于要查询tower的数目，以及删除一个tower，加入一个tower，考虑使用平衡树维护。
2. put: 首先加积木这一件事情只会使得tower发生合并操作对吧，所以可以用并查集维护点属于那个tower。关于合并积木：先查找这个位置是否本来就有积木，如果有，加上就行拉，更新一下BST中的端点的cubes就行拉；否则加上之后插入BST内，如果其左边有towers，或者右边有towers，或者两边都有删除靠右边的节点，将信息传递到左边的节点，然后在并查集内把父亲指向左边节点的左端点，没拉。
3. tput: 在某个tower内加积木，如果我知道某个tower的左端点，直接加就行了，之后更新BST内节点即可。
4. cubes: 直接把大小放到tower的最左边的端点中，查询直接输出即可。
5. lengths: 同上。
6. tcubes: 同tput。

由于要求支持k大操作，set不适用，只好手写平衡树拉>_<!!。

notice:

1. 删除节点旋转时要记录方向 int d = t->ch[0]->fix < t->ch[1]->fix; ，千万不要在这里图方便 else rot(t, t->ch[0]->fix < t->ch[1]->fix), del(t->ch[t->ch[0]->fix < t->ch[1]->fix], pos); ，因为已经把儿子转走了，如上定RE。
2. 新建指针节点一定将其指向NULL，无论之后会不会给它赋值。
3. 手残打错变量名。。。为什么每次敲数据结构题都会敲错变量名。。。

CODE:

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int maxp = 1e6;

int n;
int fa[maxn], num[maxn];

int test_on;

int find_fa(int x) {
    if(fa[x] != x) fa[x] = find_fa(fa[x]);
    return fa[x];
}


class BST {
private:
    struct treap_node {
        treap_node *ch[2];
        int fix, size, pos, cubes, length;
        treap_node() {
            ch[0] = ch[1] = NULL;
        }
        treap_node(int _pos, int _cubes, int _lengh) {
            pos = _pos, cubes = _cubes, length = _lengh;
            ch[0] = ch[1] = NULL;
            size = 1;
            fix = rand();
        }
    } *T;
    void maintain(treap_node *x) {
        if(x) {
            x->size = 1;
            if(x->ch[0]) x->size += x->ch[0]->size;
            if(x->ch[1]) x->size += x->ch[1]->size;
        }
    }
    void rot(treap_node *&x, int d) {
        treap_node *y = x->ch[d ^ 1];
        x->ch[d ^ 1] = y->ch[d];
        y->ch[d] = x;
        maintain(x), maintain(y);
        x = y;
    }
    void insert(treap_node *&t, int p, int c, int l) {
        if(t == NULL) {
            t = new treap_node(p, c, l);
        } else {
            if(p < t->pos) {
                insert(t->ch[0], p, c, l);
                if(t->ch[0]->fix < t->fix) rot(t, 1);
            } else {
                insert(t->ch[1], p, c, l);
                if(t->ch[1]->fix < t->fix) rot(t, 0);
            }
        }
        maintain(t);
    }
    void del(treap_node *&t, int pos) {
        if(t->pos == pos) {
            if(!(t->ch[0]) || !(t->ch[1])) {
                treap_node *p = t;
                if(t->ch[0]) p = t->ch[0];
                else p = t->ch[1];
                t = NULL;
                delete t;
                t = p;
            } else {
                int d = t->ch[0]->fix < t->ch[1]->fix;
                // notice
                rot(t, d);
                del(t->ch[d], pos);
            }
        } else del(t->ch[t->pos < pos], pos);
        if(t) maintain(t);
    }
    treap_node *select(int k) {
        treap_node *t = T;
        int size;
        while(1) {
            size = t->ch[0] ? t->ch[0]->size : 0;
            if(k <= size) {
                t = t->ch[0];
            } else if(k > size + 1) {
                k -= size + 1;
                t = t->ch[1];
            } else break;
        }
        return t;
    }
    treap_node *find(treap_node *t, int pos) {
        if(t == NULL || t->pos == pos) return t;
        return find(t->ch[t->pos < pos], pos);
    }

public:

    void print(treap_node *node) {
        if(node == NULL) return ;
        print(node->ch[0]);
        printf("address :%d  size :%d  fix :%d
    pos :%d  cubes :%d  length :%d
", node, node->size, node->fix, node->pos, node->cubes, node->length);
        printf("    ch[0] :%d ch[1] :%d
", node->ch[0], node->ch[1]);
        print(node->ch[1]);
    }

    int f, t, x, c;
    treap_node *r;
    void put() {
        scanf("%d%d", &x, &c);
        f = find_fa(x);
        num[x] += c;
        r = find(T, f);
        if(r == NULL) {
            insert(T, x, num[x], 1);
            treap_node *p, *q;
            p = q = NULL;
            // notice
            r = find(T, f);
            if(0 < x - 1) p = find(T, find_fa(x - 1));
            if(x + 1 <= maxp) q = find(T, find_fa(x + 1));
            if(p != NULL || q != NULL) {
                if(p != NULL) {
                    fa[r->pos] = p->pos;
                    p->cubes += r->cubes;
                    p->length += r->length;
                    del(T, r->pos);
                    r = p;
                }
                if(q != NULL) {
                    fa[q->pos] = r->pos;
                    r->cubes += q->cubes;
                    r->length += q->length;
                    // notice
                    del(T, q->pos);
                }
            }
        } else {
            r->cubes += c;
        }
        /*
        r = select(1);
        printf(" %d
", r->length);
        printf("%d
", test_on);
        print(T);
        puts("");
        */
    }
    void tcubes() {
        scanf("%d%d", &t, &x);
        r = select(t);
        printf("%d cubes in %dth column of %dth tower
", num[r->pos + x - 1], x, t);
    }
    void tput() {
        scanf("%d%d%d", &t, &x, &c);
        r = select(t);
        num[r->pos + x - 1] += c;
        r->cubes += c;
    }
    void length() {
        scanf("%d", &t);
        r = select(t);
        printf("length of %dth tower is %d
", t, r->length);
    }
    void towers() {
        printf("%d towers
", T ? T->size : 0);
    }
    void cubes() {
        scanf("%d", &t);
        r = select(t);
        printf("%d cubes in %dth tower
", r->cubes, t);
    }
} T;


char ope[10];
int main() {
#ifdef ONLINE_JUDGE
    srand((int)time(NULL));
#endif

    for(int i = 0; i < maxn; ++i) fa[i] = i;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
//        test_on = i;
//        printf("%d ", test_on);
        scanf("%s", ope);
        if(ope[0] == 'p') {
            T.put();
        } else if(ope[0] == 't' && ope[1] == 'o') {
            T.towers();
        } else if(ope[0] == 't' && ope[1] == 'p') {
//            puts("");
            T.tput();
        } else if(ope[0] == 'c') {
            T.cubes();
        } else if(ope[0] == 'l') {
            T.length();
        } else if(ope[0] == 't' && ope[1] == 'c') {
            T.tcubes();
        }
    }

    return 0;
}