普通平衡树与文艺平衡树的splay代码

主要综合借鉴了yyb和马前卒两位大佬的。

//普通平衡树
#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#define R(x) scanf("%d", &x)
#define ri readint()
#define gc getchar()
#define wi(x) printf("%d
", x)
#define ls(x) T[x].ch[0]
#define rs(x) T[x].ch[1]
using namespace std;

int readint() {
    int x = 0, s = 1, c = gc;
    while (c <= 32)    c = gc;
    if (c == '-')    s = -1, c = gc;
    for (; isdigit(c); c = gc)
        x = x * 10 + c - 48;
    return x * s;
}

struct node {
    int fa;
    int ch[2];
    int val, cnt;
    int size;
};
node T[100005];
int tot, root;

int lr(int x) {
    return x == rs(T[x].fa);
}

void Connect(int son, int fa, int way) {
    T[fa].ch[way] = son;
    T[son].fa = fa;
}

void push_up(int pos) {
    T[pos].size = T[ls(pos)].size + T[rs(pos)].size + T[pos].cnt;
}

void Rotate(int x) {
    int f = T[x].fa, gf = T[f].fa;
    int x_f = lr(x), f_gf = lr(f);
    Connect(T[x].ch[x_f^1], f, x_f);
    Connect(f, x, x_f^1);
    Connect(x, gf, f_gf);
    push_up(f);
    push_up(x);
}

void splay(int pos, int goal) {
    for (; T[pos].fa != goal; Rotate(pos)) {
        int f = T[pos].fa, gf = T[f].fa;
        if (gf != goal) {
            lr(f) ^ lr(pos) ? Rotate(pos) : Rotate(f);
        }
    }
    if (goal == 0)    root = pos;
}

void Insert(int x) {
    int pos = root, fa = 0;
    while (pos && T[pos].val != x) {
        fa = pos;
        pos = T[pos].ch[x > T[pos].val];
    }
    if (pos) {
        T[pos].cnt++;
    } else {
        pos = ++tot;
        if (fa)    T[fa].ch[x > T[fa].val] = pos;
        T[pos].ch[0] = T[pos].ch[1] = 0;
        T[pos].fa = fa;
        T[pos].val = x;
        T[pos].cnt = T[pos].size = 1;
    }
    splay(pos, 0);
}

int find(int x) {//数字val为x的位置
    int pos = root;
    if (!pos)    return 0;
    while (T[pos].ch[x > T[pos].val] && x != T[pos].val)
        pos = T[pos].ch[x > T[pos].val];
    splay(pos, 0);
    return pos;
}

int Next(int flag, int x) {//0为前驱，1为后继
    find(x);
    int pos = root;
    if (T[pos].val > x && flag)    return pos;
    if (T[pos].val < x && !flag)    return pos;
    pos = T[pos].ch[flag];
    while (T[pos].ch[flag^1]) {
        pos = T[pos].ch[flag^1];
    }
    return pos;
}

void Delet(int x) {//删除数字x
    int pos = find(x);
    if (!pos)    return;
    if (T[pos].cnt > 1) {
        T[pos].cnt--;
        T[pos].size--;
        return;
    } else {
        if (!ls(pos) && !rs(pos)) {
            root = 0;
            return;
        } else if (ls(pos) && rs(pos)) {
            int u = ls(pos);
            while (rs(u))    u = rs(u);
            splay(u, 0);
            Connect(rs(pos), u, 1);
            push_up(u);
        } else {
            if (ls(pos))    root = ls(pos);
            else    root = rs(pos);
            T[root].fa = 0;
        }
    }
}

int Rank(int x) {//数字x的排名
    find(x);
    return T[ls(root)].size + 1;
}

int Kth(int x) {//第x大的数
    int pos = root;
    if (T[pos].size < x)    return -1;
    while (true) {
        int lson = ls(pos);
        if (x > T[lson].size + T[pos].cnt) {
            x -= T[lson].size + T[pos].cnt;
            pos = rs(pos);
        } else {
            if (x > T[lson].size)    return T[pos].val;//这个题返回的是值
            pos = lson;
        }
    }
}

int main() {
    int n;
    for (n = ri; n; n--) {
        int op = ri, x = ri;
        if (op == 1)    Insert(x);
        else if (op == 2)    Delet(x);
        else if (op == 3)    wi(Rank(x));
        else if (op == 4)    wi(Kth(x));
        else    wi(T[Next(op - 5, x)].val);    
    }
    return 0;
}

//文艺平衡树
#include <cstdio>
#include <cctype>
#include <iostream>
#include <algorithm>
#define ri readint()
#define gc getchar()
#define init(a, b) memset(a, b, sizeof(a))
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define irep(i, a, b) for (int i = a; i >= b; i--)
#define ls(x) T[x].ch[0]
#define rs(x) T[x].ch[1]
using namespace std;

typedef double db;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
const int inf = 0x3f3f3f3f;
const ll INF = 1e18;

inline int readint() {
    int x = 0, s = 1, c = gc;
    while (!isdigit(c))    c = gc;
    if (c == '-')    s = -1, c = gc;
    for (; isdigit(c); c = gc)
        x = x * 10 + c - 48;
    return x * s;
}

const int maxn = 1e5 + 5;
int n, m, root, tot;
struct node {
    int fa, ch[2];
    int val, size, tag;
};
node T[maxn];

int lr(int x) {
    return x == T[T[x].fa].ch[1];
}

void connect(int son, int fa, int way) {
    T[son].fa = fa;
    T[fa].ch[way] = son;
}

void push_down(int pos) {
    if (T[pos].tag) {
        T[ls(pos)].tag ^= 1;
        T[rs(pos)].tag ^= 1;
        T[pos].tag = 0;
        swap(ls(pos), rs(pos));
    }
}

void push_up(int pos) {
    T[pos].size = T[ls(pos)].size + T[rs(pos)].size + 1;
}

void rotate(int pos) {
    int f = T[pos].fa, gf = T[f].fa;
    int x_f = lr(pos), f_gf = lr(f);
    connect(T[pos].ch[x_f^1], f, x_f);
    connect(f, pos, x_f^1);
    connect(pos, gf, f_gf);
    push_up(f);
    push_up(pos);
}

void splay(int pos, int goal) {
    for (; T[pos].fa != goal; rotate(pos)) {
        int f = T[pos].fa, gf = T[f].fa;
        if (gf != goal)
            lr(pos) ^ lr(f) ? rotate(pos) : rotate(f);
    }
    if (!goal)    root = pos;
}

void insert(int x) {
    int pos = root, fa = 0;
    while (pos && T[pos].val != x) {
        fa = pos;
        pos = T[pos].ch[x > T[pos].val];
    }
    pos = ++tot;
    if (fa)    T[fa].ch[x > T[fa].val] = pos;
    T[pos].fa = fa;
    T[pos].ch[0] = T[pos].ch[1] = 0;
    T[pos].val = x;
    T[pos].size = 1;
    T[pos].tag = 0;
    splay(pos, 0);
}

int Kth(int x) {
    int pos = root;
    while (true) {
        push_down(pos);
        int lson = ls(pos);
        if (x > T[lson].size + 1) {
            x -= T[lson].size + 1;
            pos = rs(pos);
        } else {
            if (x > T[lson].size)    return pos;
            pos = lson;
        }
    }
}

void work(int l, int r) {
    l = Kth(l), r = Kth(r + 2);
    splay(l, 0), splay(r, l);
    int pos = rs(root);
    pos = ls(pos);
    T[pos].tag ^= 1;
}

void dfs(int cur) {
    push_down(cur);
    if (T[cur].ch[0])    dfs(T[cur].ch[0]);
    if (T[cur].val != -inf && T[cur].val != inf)
        printf("%d ", T[cur].val);
    if (T[cur].ch[1])    dfs(T[cur].ch[1]);
}

int main() {
    n = ri, m = ri;
    insert(inf), insert(-inf);
    rep(i, 1, n)    insert(i);
    while (m--) {
        int l = ri, r = ri;
        work(l, r);
    }
    dfs(root);
    return 0;
}