平衡树Splay

LuoguP3369

这道题啊。。。

一开始学习的时候遇到了一篇讲的超级好的博客：rentenglong 的博客

这篇大家一定要去瞅瞅，讲的炒鸡详细（就是代码有点锅。。。）

后来找到一份和TA码风差不多的，才完善了一哈qwq

不过最终还是过了

Code:

#include <bits/stdc++.h>
#define root e[0].son[1]
using namespace std;
int read() {
    int re = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {if (ch == '-') f = -f; ch = getchar();}
    while ('0' <= ch && ch <= '9') {re = re * 10  + ch - '0'; ch = getchar();}
    return re * f;
}
const int N = 1e5 + 3;
const int INF = 1e7 + 3;
int n, cnt;
struct node{
    int v, father;//储存键值，父亲节点 
    int son[2];//存储左右孩子，son[0]为左，son[1]为右 
    int sum;//存储这个节点子树共有多少 元素 (元素包括sum + recy) 
    int recy;//存储相同键值重复多少次 
}e[N];
void update(int x) {//合并 
    e[x].sum = e[e[x].son[0]].sum + e[e[x].son[1]].sum + e[x].recy;
}
int identify(int x) {//确定当前节点与父亲节点的关系 
    return e[e[x].father].son[0] == x ? 0 : 1;
}
void connect(int x, int fa, int son) {//连接两个节点 
    e[x].father = fa;
    e[fa].son[son] = x;
}
void rotate(int x) {//核心函数之一，旋转 
    int y = e[x].father;
    int mroot = e[y].father;
    int mrootson = identify(y);
    int yson = identify(x);
    int B = e[x].son[yson ^ 1];
    connect(B, y, yson); 
    connect(y, x, (yson ^ 1));
    connect(x, mroot, mrootson);
    update(y);//y在上，先更新y 
    update(x);
}
void splay(int at, int to) {//核心函数 
    int tofa = e[to].father;
    while (e[at].father != tofa) {
        int fa = e[at].father;
        int gfa = e[fa].father;
        if (gfa != tofa) {
            if (identify(at) != identify(fa)) {
                rotate(at);//当自己的父亲与爷爷不在一条直线上时，先旋转自己 
            } else {
                rotate(fa);//当自己的父亲与爷爷在一条直线上时，先旋转父亲 
            }
        }
        rotate(at);
    }
    if (to == root) root = at;
}
int newpoint(int v, int fa) {//添加新节点 
    e[++cnt].father = fa;
    e[cnt].v = v;
    e[cnt].sum = e[cnt].recy = 1;
    return cnt;
}
void Insert(int x) {
    int now = root;
    if(!root){//特判没根的情况 
        newpoint(x, 0);
        root = cnt;
    } else {
        while (true) {
            e[now].sum++;//经过的点子树中元素都要++ 
            if (e[now].v == x) {
                e[now].recy++;//重复 
                splay(now, root);
                return;
            }
            int next = x < e[now].v ? 0 : 1;//判断该走左孩子还是右孩子 
            if (!e[now].son[next]) {
                int add = newpoint(x, now);
                e[now].son[next] = add;
                splay(add, root);
                return;
            }
            now = e[now].son[next];
        }
    }
}
int find(int v) {//查询键值为v的点的位置 
    int now = root;
    while (true) {
        if (e[now].v == v) {
            splay(now, root);//划重点，下面有用 
            return now;
        }
        int next = v < e[now].v ? 0 : 1;
        if (!e[now].son[next]) {
            return 0;
        }
        now = e[now].son[next];
    }
}
void delet(int x) {//删除节点 
    int now = find(x);//注意find()函数中已经将x转为根节点 
    if (!now) {
        return;
    }
    if (e[now].recy > 1) {//如果有重复，直接减去即可 
        e[now].recy--;
        e[now].sum--;
    } else {
        if (!e[now].son[0] && !e[now].son[1]) {//如果没有左右孩子，说明就一个点 
            root = 0;
        } else if (!e[now].son[0]) {//如果没有左孩子，直接将右孩子提为根节点 
            root = e[now].son[1];
            e[root].father = 0;
        } else {//左右孩子都有，先将左子树中最大的节点转到左孩子的位置，然后提为根节点，把右孩子连到该节点之下 
            int lef = e[now].son[0];
            while (e[lef].son[1]) {//找左子树中最大的节点 
                lef = e[lef].son[1];
            }
            splay(lef, e[now].son[0]);
            connect(e[now].son[1], lef, 1);
            connect(lef, 0, 1);
            update(lef);
        }
    }
}
int _rank(int v) {
    int now = find(v);//因为find()已经将v转为根节点，所以直接求即可 
    return e[e[now].son[0]].sum + 1;
}
int arank(int x) {
    int now = root;
    while (true) {
        int used = e[now].sum - e[e[now].son[1]].sum;
        //如果x大于左子树元素，并且小于等于当前点的左子树的sum加上本节点的recy的值，那么当前的点就是要找的点 
        //因为此时说明该x是当前节点重复值中的一个 
        if (e[e[now].son[0]].sum < x && x <= used) {
            splay(now, root);
            return e[now].v;
        }
        if (x < used) {//小于则向左子树寻找 
            now = e[now].son[0];
        } else {//大于则减去该值，再向右子树寻找 
            x -= used;
            now = e[now].son[1];
        }
    }
}
int lower(int v) {//前驱 
    int now = root;
    int ans = -INF;
    while (now) {
        if (e[now].v < v && e[now].v > ans) {
            ans = e[now].v;
        }
        if (v > e[now].v) {
            now = e[now].son[1];
        } else {
            now = e[now].son[0];
        }
    }
    return ans;
}
int upper(int v) {//后继 
    int now = root;
    int ans = INF;
    while(now) {
        if (e[now].v > v && e[now].v < ans) {
            ans = e[now].v;
        }
        if (v < e[now].v) {
            now = e[now].son[0];
        } else {
            now = e[now].son[1];
        } 
    }
    return ans;
}
int main () {
    n = read();
    while (n--) {
        int o = read();
        int x = read();
        if (o == 1) {
            Insert(x);
        } else if (o == 2) {
            delet(x);
        } else if (o == 3) {
            printf("%d
", _rank(x));
        } else if (o == 4) {
            printf("%d
", arank(x));
        } else if (o == 5) {
            printf("%d
", lower(x));
        } else if (o == 6) {
            printf("%d
", upper(x));
        }
    }
    return 0;
}