BZOJ3196:二逼平衡树(线段树套Splay)

Description

您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：
1.查询k在区间内的排名
2.查询区间内排名为k的值
3.修改某一位值上的数值
4.查询k在区间内的前驱(前驱定义为小于x，且最大的数)
5.查询k在区间内的后继(后继定义为大于x，且最小的数)

Input

第一行两个数 n,m 表示长度为n的有序序列和m个操作
第二行有n个数，表示有序序列
下面有m行，opt表示操作标号
若opt=1 则为操作1，之后有三个数l,r,k 表示查询k在区间[l,r]的排名
若opt=2 则为操作2，之后有三个数l,r,k 表示查询区间[l,r]内排名为k的数
若opt=3 则为操作3，之后有两个数pos,k 表示将pos位置的数修改为k
若opt=4 则为操作4，之后有三个数l,r,k 表示查询区间[l,r]内k的前驱
若opt=5 则为操作5，之后有三个数l,r,k 表示查询区间[l,r]内k的后继

Output

对于操作1,2,4,5各输出一行，表示查询结果

Sample Input

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

Sample Output

2
4
3
4
9

HINT

1.n和m的数据范围：n,m<=50000

2.序列中每个数的数据范围：[0,1e8]

3.虽然原题没有，但事实上5操作的k可能为负数

Solution

板子题也没啥好写的……找个好看点的板子比如我的抄抄吧

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #define N (3000000+100)
 using namespace std;

 int Root[N],sz,Father[N],Son[N][];
 int Cnt[N],Val[N],Size[N];
 int n,m,a[N],Ans,maxn;

 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
     return x*f;
 }

 struct Splay_Tree
 {
     int Get(int x) { return Son[Father[x]][]==x; }
     void Update(int x) { Size[x]=Size[Son[x][]]+Size[Son[x][]]+Cnt[x]; }
     void New(int x) { ++sz; Size[sz]=; Val[sz]=x; Cnt[sz]=; }
     void Clear(int x) { Size[x]=Father[x]=Son[x][]=Son[x][]=Cnt[x]=Val[x]=; }
     int Pre(int Root) { int now=Son[Root][]; while (Son[now][]) now=Son[now][]; return now; }
     int Next(int Root) { int now=Son[Root][]; while (Son[now][]) now=Son[now][]; return now; }

     void Rotate(int x)
     {
         int wh=Get(x),fa=Father[x],fafa=Father[fa];
         if (fafa) Son[fafa][Son[fafa][]==fa]=x;
         Father[fa]=x; Son[fa][wh]=Son[x][wh^];
         if (Son[fa][wh]) Father[Son[fa][wh]]=fa;
         Father[x]=fafa; Son[x][wh^]=fa;
         Update(fa); Update(x);
     }
     void Splay(int &Root,int x)
     {
         for (int fa;fa=Father[x];Rotate(x))
             if (Father[fa])
                 Rotate(Get(fa)==Get(x)?fa:x);
         Root=x;
     }
     int Findx(int &Root,int x)
     {
         int now=Root;
         while ()
             if (x<=Size[Son[now][]])
                 now=Son[now][];
             else
             {
                 if (x<=Cnt[now])
                 {
                     Splay(Root,now);
                     return now;
                 }
                 x-=Cnt[now];
                 now=Son[now][];
             }
     }
     int Find(int &Root,int x)
     {
         int now=Root,ans=;
         while ()
         {
             if (!now) return ans;
             if (x<Val[now])
                 now=Son[now][];
             else
             {
                 ans+=Size[Son[now][]];
                 if (Val[now]==x)
                 {
                     Splay(Root,now);
                     return ans;
                 }
                 ans+=Cnt[now];
                 now=Son[now][];
             }
         }
     }
     void Insert(int &Root,int x)
     {
         if (!Root) { New(x); Root=sz; return; }
         int now=Root,fa=;
         while ()
         {
             if (x==Val[now]) { ++Cnt[now]; Update(now); Splay(Root,now); return; }
             fa=now; now=Son[now][x>Val[now]];
             if (now==){ New(x); Father[sz]=fa; Son[fa][x>Val[fa]]=sz; Splay(Root,sz); return; }
         }
     }
     void Delete(int &Root,int x)
     {
         Find(Root,x);
         if (Cnt[Root]>) { Cnt[Root]--; Update(Root); return; }
         if (!Son[Root][] && !Son[Root][]) { Clear(Root); Root=; return; }
         if (!Son[Root][]) { Root=Son[Root][]; Clear(Father[Root]); Father[Root]=; return; }
         if (!Son[Root][]) { Root=Son[Root][]; Clear(Father[Root]); Father[Root]=; return; }

         int oldroot=Root,pre=Pre(Root);
         Splay(Root,pre);
         Son[Root][]=Son[oldroot][];
         Father[Son[oldroot][]]=Root;
         Clear(oldroot);
         Update(Root);
     }
 };

 struct Segt_Tree
 {
     Splay_Tree Splay[];
     void Get_rank(int node,int l,int r,int l1,int r1,int k)
     {
         if (l>r1 || r<l1) return;
         if (l1<=l && r<=r1)
         {
             Ans+=Splay[node].Find(Root[node],k);
             return;
         }
         int mid=(l+r)>>;
         Get_rank(node<<,l,mid,l1,r1,k);
         Get_rank(node<<|,mid+,r,l1,r1,k);
     }
     void Update(int node,int l,int r,int x,int k)
     {
         Splay[node].Delete(Root[node],a[x]);
         Splay[node].Insert(Root[node],k);
         if (l==r) return;
         int mid=(l+r)>>;
         if (x<=mid) Update(node<<,l,mid,x,k);
         else Update(node<<|,mid+,r,x,k);
     }
     void Pre(int node,int l,int r,int l1,int r1,int k)
     {
         if (l>r1 || r<l1) return;
         if (l1<=l && r<=r1)
         {
             Splay[node].Insert(Root[node],k);
             int pre=Splay[node].Pre(Root[node]);
             Ans=max(Ans,Val[pre]);
             Splay[node].Delete(Root[node],k);
             return;
         }
         int mid=(l+r)>>;
         Pre(node<<,l,mid,l1,r1,k);
         Pre(node<<|,mid+,r,l1,r1,k);
     }
     void Next(int node,int l,int r,int l1,int r1,int k)
     {
         if (l>r1 || r<l1) return;
         if (l1<=l && r<=r1)
         {
             Splay[node].Insert(Root[node],k);
             int next=Splay[node].Next(Root[node]);
             Ans=min(Ans,next==?0x7fffffff:Val[next]);
             Splay[node].Delete(Root[node],k);
             return;
         }
         int mid=(l+r)>>;
         Next(node<<,l,mid,l1,r1,k);
         Next(node<<|,mid+,r,l1,r1,k);
     }
     void Ins(int node,int l,int r,int x,int k)
     {
         Splay[node].Insert(Root[node],k);
         if (l==r) return;
         int mid=(l+r)>>;
         if (x<=mid) Ins(node<<,l,mid,x,k);
         else Ins(node<<|,mid+,r,x,k);
     }
 }T;

 int main()
 {
     n=read(),m=read();
     for (int i=; i<=n; ++i)
         a[i]=read(),maxn=max(maxn,a[i]),T.Ins(,,n,i,a[i]);
     int opt,l,r,k,pos;
     for (int i=; i<=m; ++i)
     {
         opt=read();
         switch(opt)
         {
             case :
             {
                 l=read(),r=read(),k=read();
                 Ans=;
                 T.Get_rank(,,n,l,r,k);
                 printf("%d\n",Ans+);
                 break;
             }
             case :
             {
                 l=read(),r=read(),k=read();
                 int L=,R=maxn;
                 while (L<R)
                 {
                     int mid=(L+R)>>;
                     Ans=;
                     T.Get_rank(,,n,l,r,mid);
                     if (Ans<k) L=mid+;
                     else R=mid;
                 }
                 printf("%d\n",L-);
                 break;
             }
             case :
             {
                 pos=read(),k=read();
                 T.Update(,,n,pos,k);
                 a[pos]=k;
                 maxn=max(maxn,k);
                 break;
             }
             case :
             {
                 l=read(),r=read(),k=read();
                 Ans=;
                 T.Pre(,,n,l,r,k);
                 printf("%d\n",Ans);
                 break;
             }
             case :
             {
                 l=read(),r=read(),k=read();
                 Ans=0x7fffffff;
                 T.Next(,,n,l,r,k);
                 printf("%d\n",Ans);
                 break;
             }
         }
     }
 }