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

题目背景

本题为题目 普通平衡树 的可持久化加强版。

数据已经经过强化

感谢@Kelin 提供的一组hack数据

题目描述

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

1. 插入x数

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

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

4. 查询排名为x的数

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

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

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

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

输入输出格式

输入格式：

第一行包含一个正整数N，表示操作的总数。

接下来每行包含三个整数，第 i 行记为 vi​,opti​,xi​。

vi​表示基于的过去版本号（ 0≤vi​<i ），opti​ 表示操作的序号( 1≤opt≤6 )， xi​ 表示参与操作的数值

输出格式：

每行包含一个正整数，依次为各个3,4,5,6操作所对应的答案

输入输出样例

输入样例#1：

10
0 1 9
1 1 3
1 1 10
2 4 2
3 3 9
3 1 2
6 4 1
6 2 9
8 6 3
4 5 8

输出样例#1：

9
1
2
10
3

说明

数据范围：

对于28%的数据满足： 1≤n≤10

对于44%的数据满足： 1≤n≤2⋅10^2

对于60%的数据满足： 1≤n≤3⋅10^3

对于84%的数据满足： 1≤n≤10^5

对于92%的数据满足： 1≤n≤2⋅10^5

对于100%的数据满足： 1≤n≤5⋅10^5 , −10^9≤xi​≤10^9

经实测，正常常数的可持久化平衡树均可通过，请各位放心

样例说明：

共10次操作，11个版本，各版本的状况依次是：

1. [][]

2. [9][9]

3. [3, 9][3,9]

4. [9, 10][9,10]

5. [3, 9][3,9]

6. [9, 10][9,10]

7. [2, 9, 10][2,9,10]

8. [2, 9, 10][2,9,10]

9. [2, 10][2,10]

10. [2, 10][2,10]

11. [3, 9][3,9]

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 long long read()
 {
     long long x=,f=;
     char ch=getchar();
     while(ch>''||ch<'')
     {
         if(ch=='-')
             f=-;
         ch=getchar();
     }
     while(ch>=''&&ch<='')
     {
         x=x*+ch-'';
         ch=getchar();
     }
     return x*f;
 }
 const int maxn=5e5+;
 struct node
 {
     int l,r,v,rd,sum;
 } e[maxn*];
 int n,num,x,y,opt;
 int root[maxn];
 void update(int i)
 {
     if(!i)
         return ;
     e[i].sum=e[e[i].l].sum+e[e[i].r].sum+;
 }
 int add(int x)
 {
     ++num;
     e[num].l=e[num].r=;
     e[num].sum=;
     e[num].v=x;
     e[num].rd=rand();
     return num;
 }
 int merge(int x,int y)
 {
     if(!x||!y)
         return x+y;
     if(e[x].rd>e[y].rd)
     {
         int p=++num;
         e[p]=e[x];
         e[p].r=merge(e[p].r,y);
         update(p);
         return p;
     }
     else
     {
         int p=++num;
         e[p]=e[y];
         e[p].l=merge(x,e[p].l);
         update(p);
         return p;
     }
 }
 void split(int now,int k,int &x,int &y)
 {
     if(now==)
     {
         x=y=;
         return ;
     }
     if(e[now].v<=k)
     {
         x=++num;
         e[x]=e[now];
         split(e[x].r,k,e[x].r,y);
         update(x);
     }
     else
     {
         y=++num;
         e[y]=e[now];
         split(e[y].l,k,x,e[y].l);
         update(y);
     }
 }
 void insert(int &root,int v)
 {
     int x=,y=,z=;
     split(root,v-,x,y);
     z=add(v);
     root=merge(merge(x,z),y);
 }
 void del(int &root,int v)
 {
     int x=,y=,z=;
     split(root,v,x,z);
     split(x,v-,x,y);
     y=merge(e[y].l,e[y].r);
     root=merge(merge(x,y),z);
 }
 int rank(int i,int k)
 {
     if(k==e[e[i].l].sum+)
         return e[i].v;
     if(k<=e[e[i].l].sum)
         return rank(e[i].l,k);
     return rank(e[i].r,k-e[e[i].l].sum-);
 }
 int query(int &root,int v)
 {
     int x,y;
     split(root,v-,x,y);
     int ans=e[x].sum+;
     root=merge(x,y);
     return ans;
 }
 int pre(int &root,int v)
 {
     int x,y,k;
     split(root,v-,x,y);
     if(x==)
         return -;
     k=e[x].sum;
     int ans=rank(x,k);
     root=merge(x,y);
     return ans;
 }
 int nex(int &root,int v)
 {
     int x,y,ans;
     split(root,v,x,y);
     if(y==)
         return ;
     ans=rank(y,);
     root=merge(x,y);
     return ans;
 }
 int main()
 {
     n=read();
     for(int i=; i<=n; i++)
     {
         x=read(),opt=read(),y=read();
         root[i]=root[x];
         if(opt==)
             insert(root[i],y);
         if(opt==)
             del(root[i],y);
         if(opt==)
             printf("%d\n",query(root[i],y));
         if(opt==)
             printf("%d\n",rank(root[i],y));
         if(opt==)
             printf("%d\n",pre(root[i],y));
         if(opt==)
             printf("%d\n",nex(root[i],y));
     }
     return ;
 }