【模板】可持久化平衡树 洛谷3835

题目描述

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作（对于各个以往的历史版本）：

1.插入x数

2.删除x数(若有多个相同的数，因只删除一个，如果没有请忽略该操作)

3.查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名)

4.查询排名为x的数

5.求x的前驱(前驱定义为小于x，且最大的数，如不存在输出-2147483647)

6.求x的后继(后继定义为大于x，且最小的数，如不存在输出2147483647)

和原本平衡树不同的一点是，每一次的任何操作都是基于某一个历史版本，同时生成一个新的版本。（操作3, 4, 5, 6即保持原版本无变化）

每个版本的编号即为操作的序号（版本0即为初始状态，空树）

分析

无旋treap的可持久化版本
注意细节

code

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>
#include<ctime>

#define LL long long
#define mp make_pair  

using namespace std;

const int maxn=500000*2;
const int inf=2147483647;

typedef pair<int,int> par;

struct tree{
    int lc,rc;
    int data,key;
    int size;
}t[500005*50];
int rt[maxn];

int tot;
int root;

void updata(int x)
{
    t[x].size=t[t[x].lc].size+t[t[x].rc].size+1;
}

int merge(int x,int y)
{
    if (x==0||y==0) return x+y;
    if (t[x].key<t[y].key) 
    {
        int p=++tot;t[p]=t[x];
        t[p].rc=merge(t[p].rc,y);
        return updata(p),p;
    }
    else 
    {
        int p=++tot;t[p]=t[y];
        t[p].lc=merge(x,t[p].lc);
        return updata(p),p;
    }
}

par split(int x,int n)
{
    if (n==0) 
    {
        int p=++tot;t[p]=t[x];
        return mp(0,x);
    }
    int lc=t[x].lc,rc=t[x].rc;
    if (n==t[lc].size) 
    {
        int p=++tot;t[p]=t[x];
        return t[p].lc=0,updata(p),mp(lc,p);
    }
    if (n==t[lc].size+1) 
    {
        int p=++tot;t[p]=t[x];
        return t[p].rc=0,updata(p),mp(p,rc);
    }
    if (n<t[lc].size)
    {
        par tmp=split(lc,n);
        int p=++tot;t[p]=t[x];
        return t[p].lc=tmp.second,updata(p),mp(tmp.first,p);
    }
    else
    {
        par tmp=split(rc,n-t[lc].size-1);
        int p=++tot;t[p]=t[x];
        return t[p].rc=tmp.first,updata(p),mp(p,tmp.second);
    }
}

int rank(int x,int k)
{
    int ans=0,tmp=(int)inf; 
    while (k)
    {
        if (x==t[k].data) 
        {tmp=min(tmp,ans+t[t[k].lc].size+1);}
        if (x>t[k].data) ans+=t[t[k].lc].size+1,k=t[k].rc;
        else k=t[k].lc;
    }
    return tmp==(int)inf?ans:tmp;
}

int find(int x,int k)
{
    while (true)
    {
        if (t[t[k].lc].size==x-1) return t[k].data;
        if (t[t[k].lc].size>x-1) k=t[k].lc;
        else x=x-t[t[k].lc].size-1,k=t[k].rc;
    }
}

int pre(int x,int k)
{
    int ans=-(int)inf;
    while (k)
    {
        if (t[k].data<x) ans=max(ans,t[k].data),k=t[k].rc;
        else k=t[k].lc;
    }
    return ans;
}

int net(int x,int k)
{
    int ans=(int)inf;
    while (k)
    {
        if (t[k].data>x) ans=min(ans,t[k].data),k=t[k].lc;
        else k=t[k].rc;
    }
    return ans;
}

void insert(int &rt,int x)
{
    int k=rank(x,rt);
    par tmp=split(rt,k);
    t[++tot].data=x;
    t[tot].key=rand();
    t[tot].size=1;
    rt=merge(tmp.first,tot);
    rt=merge(rt,tmp.second);
}

void del(int &rt,int x)
{
    int k=rank(x,rt);
    if ((k==0)||(find(k,rt)!=x)) return;
    par t1=split(rt,k);
    par t2=split(t1.first,k-1);
    rt=merge(t2.first,t1.second);
}

int n;

int main()
{
    srand((unsigned)time(0));
    scanf("%d",&n);
    int num=0;
    for (int i=1;i<=n;i++)
    {
        int v,op,x;
        scanf("%d%d%d",&v,&op,&x);
        rt[i]=rt[v];
        if (op>2) num++;
        if(op==1) insert(rt[i],x);
        else if(op==2) del(rt[i],x);
        else if(op==3) 
        {
            int k=rank(x,rt[i]);
            if ((k==0)||(find(k,rt[i])!=x)) k++;
            printf("%d\n",k);
        }
        else if(op==4) printf("%d\n",find(x,rt[i]));
        else if(op==5) printf("%d\n",pre(x,rt[i]));
        else printf("%d\n",net(x,rt[i]));
    }
    return 0;
}