Splay Tree (POJ 3580 & UVA 12356 & HDU 1890)

　　最近几天熟悉着用Linux，所以做题的量少了下来。这几天新学习了Splay Tree这种数据结构，于是在看懂了Splay操作以后就找了几道题来练手，除了UVA那题是1y顺利通过的，其他两题都出现了各种不同的错误，不过最终还是通过了！

　　POJ 3580是我入手Splay Tree的第一道题，这道题需要的操作包括：

　　1.区间增加相同的数

　　2.区间反转

　　3.区间滚动

　　4.插入一个数

　　5.删除一个数

　　6.查询一个区间内的最小值

　　我的Splay操作是学习《运用伸展树解决数列维护问题》的论文的，里面教的Splay和Rotate操作包括单纯的和加上更新操作两种。知道了Splay操作以后，延迟操作跟线段树的是一样的，所以不必重新再学。刚学会Splay操作的时候，还不太懂Splay的原理，所以在写insert和delete的时候各种囧态浮现。。。囧！刚开始的时候，我的insert和delete还是很笨重的写了一大串其他平衡树用的insert和delete的方法，出现各种bug以后，我忽而醒觉了，原来Everything is Splay! 这句不知道在哪里听过的话是那么的正确。用Splay Tree就是要将各种操作简化，insert或者delete的时候，只要把要insert和delete的位置Splay出来，剩下要做的事就相当简单了！

POJ 3580: poj.org/problem?id=3580

#define prog 1

#if prog == 1

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

using namespace std;

const int inf = 0x7f7f7f7f;

struct Node {
    int lateAdd, Min, Data, cnt;
    bool Rev;
    Node *c[2], *p; // 0 for left child, while 1 for right child

    Node(int _Data = inf, int _cnt = 0) {
        Rev = false;
        Min = Data = _Data;
        lateAdd = 0;
        cnt = _cnt;
        c[0] = c[1] = p = NULL;
    }
} *Null, *Root, *Head, *Tail;

void up(Node *_x) {
    Node *nl = _x->c[0], *nr = _x->c[1];

    _x->Min = min(min(nl->Min, nr->Min), _x->Data);
    _x->cnt = nl->cnt + nr->cnt + 1;
}

void down(Node *_x) {
    Node *nl = _x->c[0], *nr = _x->c[1];

    if (_x->Rev) {
        if (nl != Null) {
            swap(nl->c[0], nl->c[1]);
            nl->Rev = !nl->Rev;
        }
        if (nr != Null) {
            swap(nr->c[0], nr->c[1]);
            nr->Rev = !nr->Rev;
        }
        _x->Rev = false;
    }
    if (_x->lateAdd) {
        int late = _x->lateAdd;

        if (nl != Null) {
            nl->Min += late;
            nl->Data += late;
            nl->lateAdd += late;
        }
        if (nr != Null) {
            nr->Min += late;
            nr->Data += late;
            nr->lateAdd += late;
        }
        _x->lateAdd = 0;
    }
}

void traverse(Node *rt) {
    if (rt == Null) {
        return ;
    }
    down(rt);
    printf("rt %d  p %d  ls %d  rs %d  data %d  min %d cnt %d\n", rt, rt->p, rt->c[0], rt->c[1], rt->Data, rt->Min, rt->cnt);
    traverse(rt->c[0]);
    traverse(rt->c[1]);
}

void in_tra(Node *rt) {
    if (rt == Null) {
        return ;
    }
    down(rt);
    in_tra(rt->c[0]);
    if (rt ->Data != inf) printf("%d ", rt->Data);
    in_tra(rt->c[1]);
    up(rt);
}

void Rotate(Node *_x, bool right) { // false for left rotate, while true for right rotate
    Node *_y = _x->p;
    bool left = !right;

    down(_y);
    down(_x);
    _y->c[left] = _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;
    if (_y == Root) Root = _x;

    up(_y);
}

void Splay(Node *_x, Node *_f) {// splay _x to the node under _f
    down(_x);
    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 *getPos(int pos) {
    Node *p = Root;

    // find position
    pos++;
    while (true) {
        down(p);

        int cnt = p->c[0]->cnt;

        if (pos == cnt + 1) {
            break;
        } else if (pos <= cnt) {
            p = p->c[0];
        } else {
            pos -= cnt + 1;
            p = p->c[1];
        }
    }

    return p;
}

void insPos(int elem, int pos) {
    Node *pl = getPos(pos), *pr = getPos(pos + 1);
    Node *tmp = new Node(elem, 1);

    // insert node
    Splay(pl, Null);
    Splay(pr, pl);
    pr->c[0] = tmp;
    tmp->p = pr;
    tmp->c[0] = tmp->c[1] = Null;

    Splay(tmp, Null);
}

void delPos(int pos) {
    Node *pl = getPos(pos - 1), *pr = getPos(pos + 1);
    Node *p;

    Splay(pl, Null);
    Splay(pr, pl);
    p = pr->c[0];
    pr->c[0] = Null;

    delete p;
    Splay(pr, Null);
}

void init() {
    Null = new Node();
    Head = Root = new Node(inf, 2);
    Tail = new Node(inf, 1);

    Root->c[1] = Tail;
    Root->c[0] = Root->p = Null;
    Tail->p = Root;
    Tail->c[0] = Tail->c[1] = Null;
}

void input(int n) {
    int x;

    for (int i = 0; i < n; i++) {
        scanf("%d", &x);
        insPos(x, i);
    }
}

void reverse(int l, int r) {
    if (l == r) return ;
    Node *pl = getPos(l - 1), *pr = getPos(r + 1);

    // get segment
    Splay(pl, Null);
    Splay(pr, pl);

    pr = pr->c[0];
    swap(pr->c[0], pr->c[1]);
    pr->Rev = true;

    Splay(pr, Null);
}

void revolve(int l, int r, int t) {
    t %= (r - l + 1);
    if (l == r || t == 0) return ;

    Node *pl = getPos(r - t), *pr = getPos(r + 1);

//    printf("%d %d %d %d %d\n", pl, pr, l, r, t);

    // get segment
    Splay(pl, Null);
    Splay(pr, pl);

    // cut down segment
    Node *tmp = pr->c[0];

    pr->c[0] = Null;
    Splay(pr, Null);

    // insert segment
    pl = getPos(l - 1);
    pr = getPos(l);
    Splay(pl, Null);
    Splay(pr, pl);

    pr->c[0] = tmp;
    tmp->p = pr;
    Splay(tmp, Null);
}

void add(int l, int r, int d) {
    Node *pl = getPos(l - 1), *pr = getPos(r + 1);

//    printf("%d %d   %d %d\n", pl, pr, l, r);
    Splay(pl, Null);
    Splay(pr, pl);

    pr = pr->c[0];
    down(pr);
    pr->lateAdd += d;
    pr->Data += d;
    pr->Min += d;
    Splay(pr, Null);
}

int getMin(int l, int r) {
    Node *pl = getPos(l - 1), *pr = getPos(r + 1);

    Splay(pl, Null);
    Splay(pr, pl);
    pr = pr->c[0];
    down(pr);

    return pr->Min;
}

int main() {
    int n;
//    int cnt = 0;

//    freopen("in", "r", stdin);
//    freopen("out", "w", stdout);

    while (~scanf("%d", &n)) {
//        printf("cnt %d\n", ++cnt);
        init();
        input(n);
//        puts("Input success!");
//        puts("~~~");
//        traverse(Root);
//        puts("!!!");
        scanf("%d", &n);
//        in_tra(Root);
//        printf("~~~cnt %d\n", Root->cnt - 2);
        for (int i = 1; i <= n; i++) {
            char buf[10];
            int l, r, d ;

            scanf("%s", buf);
            if (!strcmp(buf, "ADD")) {
                scanf("%d%d%d", &l, &r, &d);
                if (l > r) swap(l, r);
                add(l, r, d);
            } else if (!strcmp(buf, "REVERSE")) {
                scanf("%d%d", &l, &r);
                if (l > r) swap(l, r);
                reverse(l, r);
            } else if (!strcmp(buf, "REVOLVE")) {
                scanf("%d%d%d", &l, &r, &d);
                if (l > r) swap(l, r);
                revolve(l, r, d);
            } else if (!strcmp(buf, "INSERT")) {
                scanf("%d%d", &l, &r);
                insPos(r, l);
            } else if (!strcmp(buf, "DELETE")) {
                scanf("%d", &l);
                delPos(l);
            } else {
                scanf("%d%d", &l, &r);
                if (l > r) swap(l, r);
                printf("%d\n", getMin(l, r));
            }

//            printf("op %d %s\n", i, buf);
//            in_tra(Root);
//            printf("~~~cnt %d\n", Root->cnt - 2);

//            puts("~~~~~~~~~~~~~");
//            traverse(Root);
//            puts("!!!!!!!!!!!!!");
        }
    }

    return 0;
}

#endif

#if prog == 2

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

using namespace std;

const int maxn = 10000;
int a[maxn], ttLen;

void input(int n) {
    ttLen = n;
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
}

void add(int l, int r, int d) {
    for (int i = l; i <= r; i++) {
        a[i] += d;
    }
}

void revolve(int l, int r, int t) {
    t %= (r - l + 1);
    if (r == l || t == 0) return ;

    int buf[maxn];

    for (int i = l; i <= r; i++) {
        buf[i - l] = a[i];
    }
    for (int i = 0; i <= r - l; i++) {
        a[(i + t) % (r - l + 1) + l] = buf[i];
    }
}

void insPos(int elem, int pos) {
    int p = ttLen;

    while (p > pos) {
        a[p + 1] = a[p];
        p--;
    }
    a[pos + 1] = elem;
    ttLen++;
}

void delPos(int pos) {
    int p = pos;

    while (p < ttLen) {
        a[p] = a[p + 1];
        p++;
    }
    ttLen--;
}

int getMin(int l, int r) {
    int ret = 0x7f7f7f7f;

    for (int i = l; i <= r; i++) {
        ret = min(ret, a[i]);
    }

    return ret;
}

int main() {
    int n;

    freopen("in", "r", stdin);
    freopen("cmp", "w", stdout);

    while (~scanf("%d", &n)) {
        input(n);

        scanf("%d", &n);
        for (int i = 1; i <= ttLen; i++) printf("%d ", a[i]);
        printf("~~~cnt %d\n", ttLen);
        for (int i = 1; i <= n; i++) {
            char buf[10];
            int l, r, d ;

            scanf("%s", buf);
            if (!strcmp(buf, "ADD")) {
                scanf("%d%d%d", &l, &r, &d);
                if (l > r) swap(l, r);
                add(l, r, d);
            } else if (!strcmp(buf, "REVERSE")) {
                scanf("%d%d", &l, &r);
                if (l > r) swap(l, r);
                reverse(a + l, a + r + 1);
            } else if (!strcmp(buf, "REVOLVE")) {
                scanf("%d%d%d", &l, &r, &d);
                if (l > r) swap(l, r);
                revolve(l, r, d);
            } else if (!strcmp(buf, "INSERT")) {
                scanf("%d%d", &l, &r);
                insPos(r, l);
            } else if (!strcmp(buf, "DELETE")) {
                scanf("%d", &l);
                delPos(l);
            } else {
                scanf("%d%d", &l, &r);
                if (l > r) swap(l, r);
                printf("%d\n", getMin(l, r));
            }

//            printf("op %d %s\n", i, buf);
//            for (int j = 1; j <= ttLen; j++) printf("%d ", a[j]);
//            printf("~~~cnt %d\n", ttLen);

        }
    }

    return 0;
}

#endif

　　下面这是昨晚训练的一道题，刚开始的时候我直接就想到了Segment Tree，可是想到这题用Segment Tree解决的代码难度相对用Splay Tree会大不少，所以我就想到了用昨天懂的Splay Tree来完成，虽然中间出现一点小问题，不过最后还是1y通过了！

　　题意是初始化一个1到n的序列，每个操作将删除指定的区间，并且返回区间两端最接近的未被删除的点的位置，如果没有就返回星号。用Splay Tree方便就是方便在删除区间的同时就找到了要输出的两个值。查找端点的时候，先找到最接近区间端点的值的结点，然后利用Splay操作，把该结点旋转至根，这样可以相当方便的找到前驱和后继。删除区间就是删除被夹逼出来的一个子树。这题给了一秒的时间，刚开始评估复杂度的时候因为Splay操作常数大，觉得可能会超时，结果不到500ms就得到结果了！

UVA 12356: uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3778

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <stack>
#include <vector>
#include <cmath>

using namespace std;
int inf = 0x7f7f7f7f;

struct Node {
    int key, cnt;
    int p, c[2];

    void init(int _key, int _cnt) {
        key = _key;
        cnt = _cnt;
        p = c[0] = c[1] = 0;
    }
} node[100010];
int Null, Root, cntNode;

void up(int rt) {
    node[rt].cnt = node[node[rt].c[0]].cnt + node[node[rt].c[1]].cnt + 1;
}

void rotate(int x, bool right) {
    int y = node[x].p;
    bool left = !right;

    node[y].c[left] = node[x].c[right];
    if (node[x].c[right] != Null) node[node[x].c[right]].p = y;
    node[x].p = node[y].p;
    if (node[y].p != Null) {
        if (node[node[y].p].c[false] == y) node[node[y].p].c[false] = x;
        else node[node[y].p].c[true] = x;
    }
    node[x].c[right] = y;
    node[y].p = x;

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

void splay(int x, int f) {
    while (node[x].p != f) {
        if (node[node[x].p].p == f) {
            if (node[node[x].p].c[0] == x) {
                rotate(x, true);
            } else {
                rotate(x, false);
            }
        } else {
            int y = node[x].p, z = node[y].p;

            if (node[z].c[false] == y) {
                if (node[y].c[false] == x) {
                    rotate(y, true);
                    rotate(x, true);
                } else {
                    rotate(x, false);
                    rotate(x, true);
                }
            } else {
                if (node[y].c[false] == x) {
                    rotate(x, true);
                    rotate(x, false);
                } else {
                    rotate(y, false);
                    rotate(x, false);
                }
            }
        }
    }
    up(x);
}

void init() {
    Null = 0;
    node[Null].init(inf, 0);
    Root = cntNode = 1;

    node[Root].init(-inf, 1);
    cntNode++;
    node[Root].c[1] = cntNode;
    node[cntNode].init(inf, 1);
    node[cntNode].p = Root;
}

int find(int key, bool right) {
    int p = Root;

    while (true) {
        if (node[p].key == key) break;
        else if (node[p].key < key) {
            if (node[p].c[1] == Null) break;
            p = node[p].c[1];
        } else {
            if (node[p].c[0] == Null) break;
            p = node[p].c[0];
        }
    }
    if (right) {
        if (node[p].key <= key) {
            splay(p, Null);
            while (node[p].key <= key) p = node[p].c[1];
            while (node[p].c[0] != Null && node[node[p].c[0]].key >= key) p = node[p].c[0];
        }
        return p;
    } else {
        if (node[p].key >= key) {
            splay(p, Null);
            while (node[p].key >= key) p = node[p].c[0];
            while (node[p].c[1] != Null && node[node[p].c[1]].key <= key) p = node[p].c[1];
        }
        return p;
    }
}

void delSeg(int &l, int &r){
    l = find(l, false);
//    puts("~~~");
    r = find(r, true);
//    puts("!!!");
//    printf("%d %d\n", l, r);
//    printf("%d %d\n", node[l].key, node[r].key);
    splay(l, Null);
    splay(r, l);
    node[r].c[0] = Null;
}

void build(int n) {
    init();
    for (int i = 1; i <= n; i++) {
        cntNode++;
        node[cntNode].init(i, 1);
        node[cntNode].c[1] = node[Root].c[1];
        node[node[Root].c[1]].p = cntNode;
        node[Root].c[1] = cntNode;
        node[cntNode].p = Root;

        splay(cntNode, Null);
    }
}

void in_tra(int rt) {
    if (rt == Null) return ;
    in_tra(node[rt].c[0]);
    printf("%d ", node[rt].key);
    in_tra(node[rt].c[1]);
}

int main() {
//    freopen("in", "r", stdin);
//    freopen("out", "w", stdout);

    int n, m;

    while (~scanf("%d%d", &n, &m) && (n + m)) {
        build(n);
        while (m--) {
            int l, r;

            scanf("%d%d", &l, &r);
            delSeg(l, r);
            if (node[l].key == -inf) putchar('*');
            else printf("%d", node[l].key);
            putchar(' ');
            if (node[r].key == inf) putchar('*');
            else printf("%d", node[r].key);
            puts("");
        }
        puts("-");
    }

    return 0;
}

　　下面这题也是是比较简单的，只用到了反转操作，不过数列不是一个单纯的排列，所以要先处理出稳定排序后的结果，重新附上标号以后就可以直接模拟了！

HDU 1890: acm.hdu.edu.cn/showproblem.php?pid=1890

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

using namespace std;

const int inf = 0x7f7f7f7f;
struct Node {
    int cnt;
    bool rev;
    Node *c[2], *p;

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

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

void init() {
    Null = new Node();
    Root = new Node(1);

    Root->c[0] = Root->p = Null;
    Root->c[1] = new Node(1);
    Root->c[1]->p = Root;
    Root->c[1]->c[0] = Root->c[1]->c[1] = Null;
    up(Root);
}

void down(Node *rt) {
    Node *ls = rt->c[0], *rs = rt->c[1];

    if (rt->rev) {
        if (ls != Null) {
            swap(ls->c[0], ls->c[1]);
            ls->rev = !ls->rev;
        }
        if (rs != Null) {
            swap(rs->c[0], rs->c[1]);
            rs->rev = !rs->rev;
        }
        rt->rev = false;
    }
}

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

    down(y);
    down(x);
    y->c[left] = 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 (y == Root) Root = x;
}

void splay(Node *x, Node *f) {
    down(x);

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

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

    up(x);
}

const int maxn = 100005;
struct List {
    int data;
    int pri;
} list[maxn];
Node *rec[maxn];

bool cmp1(List _a, List _b) {
    if (_a.data != _b.data) return _a.data < _b.data;
    return _a.pri < _b.pri;
}

bool cmp2(List _a, List _b) {
    return _a.pri < _b.pri;
}

Node *getNode(int pos) {
    Node *p = Root;

    pos++;
    while (true) {
        down(p);

        int c = p->c[0]->cnt;

        if (pos == c + 1) {
            return p;
        } else if (pos <= c) {
            p = p->c[0];
        } else {
            pos -= c + 1;
            p = p->c[1];
        }
    }
}

void insPos(int data, int pos) {
    Node *pl = getNode(pos), *pr = getNode(pos + 1);

    splay(pl, Null);
    splay(pr, pl);

    Node *tmp = new Node(1);

    down(pr);
    rec[data] = tmp;
    pr->c[0] = tmp;
    tmp->p = pr;
    tmp->c[0] = tmp->c[1] = Null;

    splay(tmp, Null);
}

int getPos(Node *x) {
    splay(x, Null);

    return x->c[0]->cnt;
}

void reverse(int n) {
    Node *pl = getNode(n), *pr = getNode(getPos(rec[n]) + 1);

    if (pl->c[1] == rec[n]) return ;
    splay(pl, Null);
    splay(pr, pl);

    pr = pr->c[0];
    down(pr);
    pr->rev = !pr->rev;
    swap(pr->c[0], pr->c[1]);

    splay(pr, Null);
}

void in_tra(Node *rt) {
    if (rt == Null) {
        return ;
    }
    down(rt);
    in_tra(rt->c[0]);
    printf("%d %d %d p %d\n", rt, rt->c[0], rt->c[1], rt->p);
    in_tra(rt->c[1]);
}

void pre(int n) {
    sort(list, list + n, cmp1);
    for (int i = 0; i < n; i++) {
        list[i].data = i;
    }
    sort(list, list + n, cmp2);
    for (int i = 0; i < n; i++) {
        insPos(list[i].data, i);
    }
}

void build(int n) {
    init();
    for (int i = 0, x; i < n; i++) {
        scanf("%d", &x);
        list[i].data = x;
        list[i].pri = i;
    }
    pre(n);
}

void deal(int n) {
//    in_tra(Root);
//    puts("~~~");
//    for (int i = 0; i < n; i++) {
//        printf("%d %d\n", i, rec[i]);
//    }
//    printf("%d\n", n);
    for (int i = 0; i < n; i++) {
        if (i) putchar(' ');
        printf("%d", getPos(rec[i]));
        reverse(i);
    }
    puts("");
}

int main() {
    int n;

//    freopen("in", "r", stdin);
//    freopen("out", "w", stdout);
    while (~scanf("%d", &n) && n) {
        build(n);
        deal(n);
    }

    return 0;
}

　　做这几题Splay Tree，暂时没遇到比较难的操作，不过Splay Tree的代码都有一定的长度的啊！如果没打好，debug起来是挺吃力的。。。囧！

　　另外，除了中间那题，其余两题都是用动态内存处理的！

——written by Lyon