SPOJ ORDERSET Order statistic set 非旋转treap

最新推荐文章于 2018-05-04 17:28:19 发布

原创最新推荐文章于 2018-05-04 17:28:19 发布 · 300 阅读

0 ·

CC 4.0 BY-SA版权

treap 专栏收录该内容

5 篇文章

订阅专栏

本文介绍了一种使用非旋转版Treap实现OrderSet的方法，包括插入、删除、查找指定排名元素及统计小于指定值的元素数量等操作。通过具体代码示例展示了Treap的基本结构与关键操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

https://vjudge.net/problem/SPOJ-ORDERSET

题意：

有下面四种操作：

I x 往集合中插入x，若存在则不操作
D x 从集合中删除x，若不存在则不操作
K x 求集合中第x大的数，若x大于集合的大小输出invalid
C x 统计集合中小于x的数的个数

思路：

非旋转版treap，主要操作是基于 $split$ 和 $merge$

#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> proot;
const int N = 200000 + 10;

struct node
{
    int l, r, val, pri, sz;
    void init(int _val, int _pri, int _sz)
    {
        val = _val, pri = _pri, sz = _sz;
        l = r = 0;
    }
}tr[N];
int root, tot;
void init()
{
    root = 0, tot = 0;
    tr[0].init(0, 0, 0);
}
int new_node(int val)
{
    tr[++tot].init(val, rand(), 1);
    return tot;
}
void update(int x)
{
    tr[x].sz = 1 + tr[tr[x].l].sz + tr[tr[x].r].sz;
}
proot split(int x, int k)//把树x分裂成两个树，前k个元素一个数，剩余的元素一个树
{
    if(! k) return proot(0, x);
    proot y;
    if(tr[tr[x].l].sz >= k)
    {
        y = split(tr[x].l, k);
        tr[x].l = y.second;
        update(x);
        y.second = x;
    }
    else
    {
        y = split(tr[x].r, k - tr[tr[x].l].sz - 1);
        tr[x].r = y.first;
        update(x);
        y.first = x;
    }
    return y;
}
int Merge(int x, int y)//把树x,y合并成一棵，并返回树根
{
    if(!x || !y) return x + y;
    if(tr[x].pri < tr[y].pri)
    {
        tr[x].r = Merge(tr[x].r, y);
        update(x);
        return x;
    }
    else
    {
        tr[y].l = Merge(x, tr[y].l);
        update(y);
        return y;
    }
}
bool Find(int x, int val)
{
    if(!x) return false;
    if(val == tr[x].val) return true;
    else if(val < tr[x].val) return Find(tr[x].l, val);
    else return Find(tr[x].r, val);
}
int get_rank(int x, int val)
{
    if(!x) return 0;
    if(val == tr[x].val) return tr[tr[x].l].sz + 1;
    else if(val < tr[x].val) return get_rank(tr[x].l, val);
    else return tr[tr[x].l].sz + 1 + get_rank(tr[x].r, val);
}
int get_kth(int x, int k)
{
    if(tr[tr[x].l].sz + 1 == k) return tr[x].val;
    else if(k <= tr[tr[x].l].sz) return get_kth(tr[x].l, k);
    else return get_kth(tr[x].r, k - tr[tr[x].l].sz - 1);
}
void Insert(int val)
{//插入元素。首先确定新元素的排名，然后依据这个排名把树分裂成两个，然后把新元素夹在两个树中间，合并
    int k = get_rank(root, val);
    proot x = split(root, k);
    int y = new_node(val);
    root = Merge(Merge(x.first, y), x.second);
}
void del(int val)
{//删除元素。首先确定元素排名k，然后前k-1个分裂成一个树，剩余的元素再进行一次分裂，把第一个也就是待删除元素单独分裂出来，然后合并即可
    int k = get_rank(root, val);
    proot x = split(root, k-1);
    proot y = split(x.second, 1);
    root = Merge(x.first, y.second);
}
int main()
{
    int n;
    while(~ scanf("%d", &n))
    {
        init();
        char opt;
        int x, num = 0;
        for(int i = 1; i <= n; i++)
        {
            scanf(" %c%d", &opt, &x);
            if(opt == 'I')
            {
                if(! Find(root, x)) Insert(x), num++;
            }
            else if(opt == 'D')
            {
                if(Find(root, x)) del(x), num--;
            }
            else if(opt == 'K')
            {
                if(x > num) puts("invalid");
                else printf("%d\n", get_kth(root, x));
            }
            else if(opt == 'C')
            {
                int tmp = Find(root, x) ? 1 : 0;
                printf("%d\n", get_rank(root, x) - tmp);
            }
        }
    }
    return 0;
}