poj 2892 Tunnel Warfare (Splay Tree instead of Segment Tree)

poj.org/problem?id=2892

　　poj上的一道数据结构题，这题正解貌似是Segment Tree，不过我用了Splay Tree来写，而且我个人认为，这题用Splay Tree会更好写！

　　先简单解释一下题意：有n个连续的村庄，有以下几种操作(1)破坏一个村庄(2)问某个村庄与多少个村庄相连(包括它本身)(3)重建之前破坏了的村庄。

　　这道题用Splay Tree做要用到一个类似DLX(Dancing Links)的操作，就是结点的假删除，用到这个题上可以说是相当的巧妙的。我们在删除结点前把结点Splay到根的位置，然后删除的只是子结点指向父结点(也就是现在要删除的结点)的指针。不过父结点不回收，也就是他的两个子结点的指针并不删除。这样我们就可以快速的找回恢复用到的子结点了！每种操作借助splay来完成，十分简洁。时间还是可以接受的400ms。

　　可能有人会问，恢复一个结点，假设编号为x，用到它的两个子结点不是就是处于它两侧的x-1和x+1吗？当然，这也是可以的。这时，我们就要将0和n+1指向Null了。

代码如下：

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

using namespace std;

const int maxn = 5e4 + 5;

struct Node {
    int cnt;
    bool ex;
    Node *c[2], *p;

    Node(int _cnt = 0, bool _ex = false) {
        cnt = _cnt;
        c[0] = c[1] = p = NULL;
        ex = _ex;
    }
} *Null, *Root;

void up(Node *rt) {
    rt->cnt = rt->c[0]->cnt + rt->c[1]->cnt + 1;
}

void rotate(Node *x, bool right) {
    Node *y = x->p;

    y->c[!right] = x->c[right];
    if (x->c[right] != Null) x->c[right]->p = y;
    x->p = y->p;
    if (y->p != Null) {
        if (y->p->c[0] == y) y->p->c[0] = x;
        else y->p->c[1] = x;
    }
    x->c[right] = y;
    y->p = x;
    up(y);

    if (Root == y) Root = x;
}

void splay(Node *x, Node *f) {
    while (x->p != f) {
        if (x->p->p == f) {
            if (x->p->c[0] == x) rotate(x, 1);
            else rotate(x, 0);
        } else {
            Node *y = x->p, *z = y->p;

            if (z->c[0] == y) {
                if (y->c[0] == x) {
                    rotate(y, 1);
                    rotate(x, 1);
                } else {
                    rotate(x, 0);
                    rotate(x, 1);
                }
            } else {
                if (y->c[0] == x) {
                    rotate(x, 1);
                    rotate(x, 0);
                } else {
                    rotate(y, 0);
                    rotate(x, 0);
                }
            }
        }
    }
    up(x);
}

Node *village[maxn];
int s[maxn], top;

void build(int n) {
    Null = new Node();
    Root = new Node(1, true);
    Root->p = Root->c[0] = Root->c[1] = Null;
    village[1] = Root;

    for (int i = 2; i <= n; i++){
        village[i] = new Node(1, true);
        village[i]->p = Root;
        village[i]->c[0] = village[i]->c[1] = Null;
        splay(village[i], Null);
    }
    top = -1;
}

void destroy(int x) {
    splay(village[x], Null);
    village[x]->c[0]->p = village[x]->c[1]->p = Null;
    village[x]->ex = false;
    s[++top] = x;
}

int query(int x) {
    if (!village[x]->ex) return 0;
    splay(village[x], Null);
    return village[x]->cnt;
}

void rebuild() {
    if (top < 0) return ;

    int x = s[top];
    top--;

    if (village[x]->c[0] != Null) splay(village[x]->c[0], Null);
    if (village[x]->c[1] != Null) splay(village[x]->c[1], Null);
    village[x]->c[0]->p = village[x];
    village[x]->c[1]->p = village[x];
    village[x]->ex = true;
    up(village[x]);
}

int main() {
    char op[3];
    int n, m, a;

//    freopen("in", "r", stdin);
    while (~scanf("%d%d", &n, &m)) {
        build(n);
//        printf("built %d\n", n);
        while (m--) {
            scanf("%s", op);
            switch (op[0]) {
                case 'D' :
                    scanf("%d", &a);
                    destroy(a);
                    break;
                case 'Q' :
                    scanf("%d", &a);
                    printf("%d\n", query(a));
                    break;
                case 'R' :
                    rebuild();
                    break;
            }
//            printf("m %d\n", m);
        }
    }

    return 0;
}

　　做了这么多题，debug Splay Tree的时候主要是要检查是否每个修改结点的操作都伴随着spaly操作，另外一个就是更新函数有没有错。总的来说，一个splay就可以满足你的各种要求了！不过就像论文里说的，有些题目线段树能做就不要用Splay Tree，因为Splay Tree的常数大，代码量也是不少的，这个看回之前几个入门级的Splay Tree就可以发现了，每个都少则200+，多则300+行。

UPD：

Problem - 1540

　　同样的题，用线段树做的：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 55555;
int lc[N << 2], rc[N << 2], pos[N], len[N << 2];

#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
#define root 1, n, 1

void up(int rt) {
    int ls = rt << 1, rs = rt << 1 | 1;
    lc[rt] = lc[ls];
    if (lc[ls] == len[ls]) lc[rt] += lc[rs];
    rc[rt] = rc[rs];
    if (rc[rs] == len[rs]) rc[rt] += rc[ls];
}

void build(int l, int r, int rt) {
    len[rt] = r - l + 1;
//    cout << l << ' ' << r << ' ' << rt << ' ' << len[rt] << endl;
    if (l >= r) {
        lc[rt] = rc[rt] = 1;
        pos[l] = rt;
        return ;
    }
    int m = l + r >> 1;
    build(lson);
    build(rson);
    up(rt);
}

int st[N], top;

void destroy(int x) {
    st[++top] = x;
//    cout << "fuck " << x << endl;
    x = pos[x];
    lc[x] = rc[x] = 0;
    while ((x >>= 1) > 0) up(x);
}

void rebuild() {
    int x = st[top--];
//    cout << "shit " << x << endl;
    x = pos[x];
    lc[x] = rc[x] = 1;
    while ((x >>= 1) > 0) up(x);
}

typedef pair<bool, bool> PBB;
typedef pair<int, PBB> PIBB;

PIBB query(int x, int l, int r, int rt) {
    if (l >= r) return PIBB(lc[rt], PBB(lc[rt], lc[rt]));
    int m = l + r >> 1;
    PIBB tmp;
    int ls = rt << 1, rs = rt << 1 | 1;
    if (x <= m) {
        tmp = query(x, lson);
        if (tmp.second.second) {
            tmp.first += lc[rs];
            tmp.second.second = lc[rs] == len[rs];
        }
    } else {
        tmp = query(x, rson);
        if (tmp.second.first) {
            tmp.first += rc[ls];
            tmp.second.first = rc[ls] == len[ls];
        }
    }
    return tmp;
}

int main() {
//    freopen("in", "r", stdin);
    int n, m, x;
    char buf[3];
    while (~scanf("%d%d", &n, &m)) {
        top = -1;
        build(root);
        while (m--) {
            scanf("%s", buf);
            if (buf[0] == 'D') {
                scanf("%d", &x);
                destroy(x);
            }
            if (buf[0] == 'R') rebuild();
            if (buf[0] == 'Q') {
                scanf("%d", &x);
                printf("%d\n", query(x, root).first);
            }
        }
    }
    return 0;
}

 UPD：

　　还有一种威武霸气的好方法。想法源自LRC。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <set>
#include <stack>

using namespace std;

set<int> pos, neg;
stack<int> st;
int main() {
//    freopen("in", "r", stdin);
    int n, m, x;
    while (~scanf("%d%d", &n, &m)) {
        pos.clear(), neg.clear();
        while (!st.empty()) st.pop();
        pos.insert(0), pos.insert(n + 1);
        neg.insert(0), neg.insert(-n - 1);
        char buf[3];
        while (m--) {
            scanf("%s", &buf);
            if (buf[0] == 'D') {
                scanf("%d", &x);
                pos.insert(x), neg.insert(-x);
                st.push(x);
            }
            if (buf[0] == 'R') {
                pos.erase(st.top()), neg.erase(-st.top());
                st.pop();
            }
            if (buf[0] == 'Q') {
                scanf("%d", &x);
                printf("%d\n", max(0, *neg.lower_bound(-x) + *pos.lower_bound(x) - 1));
            }
        }
    }
    return 0;
}

——written by Lyon