普通平衡树与文艺平衡树的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\n", x)
 #define ls(x) T[x].ch[0]
 #define rs(x) T[x].ch[1]
 using namespace std;

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

 struct node {
     int fa;
     int ch[];
     int val, cnt;
     int size;
 };
 node T[];
 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^], f, x_f);
     Connect(f, x, x_f^);
     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 == )    root = pos;
 }

 void Insert(int x) {
     int pos = root, fa = ;
     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[] = T[pos].ch[] = ;
         T[pos].fa = fa;
         T[pos].val = x;
         T[pos].cnt = T[pos].size = ;
     }
     splay(pos, );
 }

 int find(int x) {//数字val为x的位置
     int pos = root;
     if (!pos)    return ;
     while (T[pos].ch[x > T[pos].val] && x != T[pos].val)
         pos = T[pos].ch[x > T[pos].val];
     splay(pos, );
     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^]) {
         pos = T[pos].ch[flag^];
     }
     return pos;
 }

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

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

 int Kth(int x) {//第x大的数
     int pos = root;
     if (T[pos].size < x)    return -;
     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 == )    Insert(x);
         else if (op == )    Delet(x);
         else if (op == )    wi(Rank(x));
         else if (op == )    wi(Kth(x));
         else    wi(T[Next(op - , x)].val);
     }
     return ;
 }

 //文艺平衡树
 #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 = , s = , c = gc;
     while (!isdigit(c))    c = gc;
     if (c == '-')    s = -, c = gc;
     for (; isdigit(c); c = gc)
         x = x *  + c - ;
     return x * s;
 }

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

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

 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 ^= ;
         T[rs(pos)].tag ^= ;
         T[pos].tag = ;
         swap(ls(pos), rs(pos));
     }
 }

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

 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^], f, x_f);
     connect(f, pos, x_f^);
     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 = ;
     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[] = T[pos].ch[] = ;
     T[pos].val = x;
     T[pos].size = ;
     T[pos].tag = ;
     splay(pos, );
 }

 int Kth(int x) {
     int pos = root;
     while (true) {
         push_down(pos);
         int lson = ls(pos);
         if (x > T[lson].size + ) {
             x -= T[lson].size + ;
             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 + );
     splay(l, ), splay(r, l);
     int pos = rs(root);
     pos = ls(pos);
     T[pos].tag ^= ;
 }

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

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