洛谷P3369 普通平衡树题解(非旋Treap)题解

题目链接

有旋Treap见此

可持续化情况

题意

您需要写一种数据结构，来维护一些数，其中需要提供以下操作：
case 1: 插入$x$数
case 2: 删除$x$数(若有多个相同的数，因只删除一个)
case 3: 查询$x$数的排名(排名定义为比当前数小的数的个数$+1$)
case 4: 查询排名为$x$的数
case 5: 求$x$的前驱(前驱定义为小于$x$,且最大的数)
case 6: 求$x$的后继(后继定义为大于$x$,且最小的数)

这就是一个模板题，这里提供一个链接，讲述非常详细，如下链接

$\text{实测可以过的}$

代码(有作用注释)

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <cctype>
#include <map>
#include <set>
#include <vector>
#include <iostream>
#include <cmath>
#define pk putchar(' ')
#define ph puts("")
#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
template <class T>
void rd(T &x)
{
    x = 0;
    int f = 1;
    char c = getchar();
    while (!isdigit(c)) {if (c == '-') f = -1; c = getchar();}
    while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
    x *= f;
}
template <class T>
void pt(T x)
{
    if (x < 0)
        putchar('-'), x = (~x) + 1;
    if (x > 9)
        pt(x / 10);
    putchar(x % 10 ^ 48);
}
template <class T>
T Max(T a, T b)
{
    return a > b ? a : b;
}
template <class T>
T Min(T a, T b)
{
    return a < b ? a : b;
}
using namespace std;
const int INF = 0x3f3f3f3f, N = 1e5 + 5;
int n;
struct Node 
{
    int val, key, siz, l ,r;
    void clear()
    {
        val = key = siz = l = r = 0;
    }
};
struct Treapnode
{
    Node t[N];
    int tot, root;
    void update(int now)
    {
        t[now].siz = t[t[now].l].siz + t[t[now].r].siz + 1;
    }
    // 更新
    int merge(int u, int v) 
    { 
        if (!u || !v) 
            return u | v; 
        if (t[u].key < t[v].key) 
        {
            t[u].r = merge(t[u].r, v); 
            update(u); 
            return u;
        } 
        else 
        {
            t[v].l = merge(u, t[v].l); 
            update(v); 
            return v;
        }
    }
    // 合并
    void split_val(int now, int k, int& x, int& y) 
    {
        if (!now) 
            return (void)(x = y = 0); 
        if (t[now].val <= k) 
            x = now, split_val(t[now].r, k, t[now].r, y);
        else 
            y = now, split_val(t[now].l, k, x, t[now].l);
        update(now);
    }
    // 按权值大小拆分
    void split_k(int now, int k, int& x, int& y) 
    {
        if (!now) 
            return (void)(x = y = 0);
        update(now);
        if (t[t[now].l].siz < k)
            x = now, split_k(t[now].r, k - t[t[now].l].siz - 1, t[now].r, y);
        else
            y = now, split_k(t[now].l, k, x, t[now].l);
        update(now);
    }
    // 按排名大小拆分
    void ins(int x) 
    {
        int u, a, b;
        t[u = ++tot].key = rand();
        t[u].val = x, t[u].siz = 1;
        split_val(root, x, a, b);
        root = merge(merge(a, u), b);
    }
    // 插入x
    void del(int x) 
    {
        int a ,b ,c ,d;
        split_val(root, x - 1, a, b);
        split_k(b, 1, c, d);
        t[c].clear();
        root = merge(a, d);
    }
    // 删除x
    int get_rank(int x) 
    {
        int a, b, c;
        split_val(root, x - 1, a, b);
        c = t[a].siz + 1;
        root = merge(a, b);
        return c;
    }
    // 得到x的排名
    int get_val(int& now, int x) 
    {
        int a, b, c, d, e;
        split_k(now, x - 1, a, b);
        split_k(b, 1, c, d);
        e = t[c].val;
        now = merge(a, merge(c, d));
        return e;
    }
    // 以root为根的找第x的值
    int pre(int x) 
    {
        int a, b, c;
        split_val(root, x - 1, a, b);
        c = get_val(a, t[a].siz);
        root = merge(a, b);
        return c;
    }
    // 找前驱
    int sub(int x) 
    {
        int a, b, c;
        split_val(root, x, a, b);
        c = get_val(b, 1);
        root = merge(a, b);
        return c;
    }
    // 找后缀
}Treap;
int main() 
{
    rd(n);
    int opt, x;
    while(n--)
    {
        rd(opt), rd(x);
        switch(opt)
        {
            case 1: Treap.ins(x); break;
            case 2: Treap.del(x); break;
            case 3: pt(Treap.get_rank(x)), ph; break;
            case 4: pt(Treap.get_val(Treap.root, x)), ph; break;
            case 5: pt(Treap.pre(x)), ph; break;
            case 6: pt(Treap.sub(x)), ph; break;
        }
    }
    return 0;
}

Thanks!