[BZOJ3196] [Tyvj1730] 二逼平衡树（线段树 套 Splay）

传送门

至少BZOJ过了，其他的直接弃。

您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：

1.查询k在区间内的排名

2.查询区间内排名为k的值

3.修改某一位值上的数值

4.查询k在区间内的前驱(前驱定义为小于x，且最大的数)

5.查询k在区间内的后继(后继定义为大于x，且最小的数)

最外层套一颗线段树，用来表示区间，线段树下面套个splay用来维护当前线段树节点的区间。

对于第二问可以二分，看看哪个数的排名为 k。

——代码

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #define root 1, 1, n
 #define lson now << 1, l, mid
 #define rson now << 1 | 1, mid + 1, r
 #define ls son[now][0]
 #define rs son[now][1]
 #define debug puts("**************");

 const int MAXN = , INF = ;

 int n, m, sz;
 int seq[MAXN], rt[MAXN];
 int f[MAXN], son[MAXN][], cnt[MAXN], key[MAXN], size[MAXN];

 inline int read()
 {
     int f = , x = ;
     char ch = getchar();
     for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -;
     for(; isdigit(ch); ch = getchar()) x = (x << ) + (x << ) + ch - '';
     return x * f;
 }

 inline int max(int x, int y)
 {
     return x > y ? x : y;
 }

 inline int min(int x, int y)
 {
     return x < y ? x : y;
 }

 inline void Splay_clear(int now)
 {
     f[now] = cnt[now] = key[now] = size[now] = ls = rs = ;
 }

 inline void Splay_update(int now)
 {
     if(now)
     {
         size[now] = cnt[now];
         if(ls) size[now] += size[ls];
         if(rs) size[now] += size[rs];
     }
 }

 inline int Splay_get(int x)
 {
     return son[f[x]][] == x;
 }

 inline void Splay_rotate(int x)
 {
     int old = f[x], oldf = f[old], wh = Splay_get(x);

     son[old][wh] = son[x][wh ^ ];
     f[son[old][wh]] = old;

     son[x][wh ^ ] = old;
     f[old] = x;

     if(oldf) son[oldf][son[oldf][] == old] = x;
     f[x] = oldf;

     Splay_update(old);
     Splay_update(x);
 }

 inline void Splay_splay(int x)
 {
     for(int fa; fa = f[x]; Splay_rotate(x))
         if(f[fa])
             Splay_rotate(Splay_get(x) ^ Splay_get(fa) ? x : fa);
 }

 inline void Splay_insert(int x, int k)
 {
     int now = rt[x], fa = ;
     if(!rt[x])
     {
         rt[x] = ++sz;
         key[sz] = k;
         size[sz] = cnt[sz] = ;
         return;
     }
     while()
     {
         if(k == key[now])
         {
             cnt[now]++;
             Splay_update(now);
             Splay_splay(now);
             rt[x] = now;
             return;
         }
         fa = now;
         now = son[now][k > key[now]];
         if(!now)
         {
             rt[x] = ++sz;
             f[sz] = fa;
             key[sz] = k;
             size[sz] = cnt[sz] = ;
             son[fa][k > key[fa]] = sz;
             //Splay_update(fa);
             Splay_splay(sz);
             return;
         }
     }
 }

 inline int Splay_findrank(int x, int k)
 {
     int now = rt[x], ans = ;
     while()
     {
         if(!now) return ans;
         if(key[now] == k) return ans + size[ls];
         else if(key[now] < k)
         {
             ans += cnt[now] + size[ls];
             now = rs;
         }
         else now = ls;
     }
 }

 inline int Splay_find(int x, int k)
 {
     int now = rt[x];
     while()
     {
         if(key[now] > k) now = ls;
         else if(key[now] < k) now = rs;
         else
         {
             rt[x] = now;
             Splay_splay(now);
             return now;
         }
     }
 }

 inline int Splay_pre(int x)
 {
     int now = son[rt[x]][];
     while(rs) now = rs;
     return now;
 }

 inline int Splay_suc(int x)
 {
     int now = son[rt[x]][];
     while(ls) now = ls;
     return now;
 }

 inline void Splay_del(int x)
 {
     int now = rt[x];
     if(cnt[now] > )
     {
         cnt[now]--;
         Splay_update(now);
         return;
     }
     if(!ls && !rs)
     {
         rt[x] = ;
         Splay_clear(now);
         return;
     }
     if(!ls || !rs)
     {
         rt[x] = ls + rs;
         f[rt[x]] = ;
         Splay_clear(now);
         return;
     }
     int pre = Splay_pre(x);
     Splay_splay(pre);
     rt[x] = pre;
     son[pre][] = rs;
     f[rs] = pre;
     Splay_clear(now);
     Splay_update(pre);
 }

 inline int Splay_findpre(int x, int k)
 {
     int now = rt[x], ans = -INF;
     while(now)
     {
         if(key[now] < k)
         {
             ans = max(ans, key[now]);
             now = rs;
         }
         else now = ls;
     }
     return ans;
 }

 inline int Splay_findsuc(int x, int k)
 {
     int now = rt[x], ans = INF;
     while(now)
     {
         if(key[now] > k)
         {
             ans = min(ans, key[now]);
             now = ls;
         }
         else now = rs;
     }
     return ans;
 }

 inline void SegTree_insert(int x, int k, int now, int l, int r)
 {
     Splay_insert(now, k);
     if(l == r) return;
     int mid = (l + r) >> ;
     if(x <= mid) SegTree_insert(x, k, lson);
     else SegTree_insert(x, k, rson);
 }

 inline int SegTree_askrank(int x, int y, int k, int now, int l, int r)
 {
     if(x <= l && r <= y) return Splay_findrank(now, k);
     if(l > y || r < x) return ;
     int mid = (l + r) >> ;
     return SegTree_askrank(x, y, k, lson) + SegTree_askrank(x, y, k, rson);
 }

 inline void SegTree_change(int x, int k, int now, int l, int r)
 {
     Splay_find(now, seq[x]);
     Splay_del(now);
     Splay_insert(now, k);
     if(l == r) return;
     int mid = (l + r) >> ;
     if(x <= mid) SegTree_change(x, k, lson);
     else SegTree_change(x, k, rson);
 }

 inline int SegTree_findpre(int x, int y, int k, int now, int l, int r)
 {
     if(x <= l && r <= y) return Splay_findpre(now, k);
     if(l > y || r < x) return -INF;
     int mid = (l + r) >> ;
     return max(SegTree_findpre(x, y, k, lson), SegTree_findpre(x, y, k, rson));
 }

 inline int SegTree_findsuc(int x, int y, int k, int now, int l, int r)
 {
     if(x <= l && r <= y) return Splay_findsuc(now, k);
     if(l > y || r < x) return INF;
     int mid = (l + r) >> ;
     return min(SegTree_findsuc(x, y, k, lson), SegTree_findsuc(x, y, k, rson));
 }

 int main()
 {
     int i, opt, x, y, z, ans, h, t, mid, maxn = ;
     n = read();
     m = read();
     for(i = ; i <= n; i++) seq[i] = read(), maxn = max(maxn, seq[i]), SegTree_insert(i, seq[i], root);
     for(i = ; i <= m; i++)
     {
         opt = read();
         switch(opt)
         {
             case :
             {
                 x = read();
                 y = read();
                 z = read();
                 printf("%d\n", SegTree_askrank(x, y, z, root) + );
                 break;
             }
             case :
             {
                 x = read();
                 y = read();
                 z = read();
                 h = , t = maxn;
                 while(h <= t)
                 {
                     mid = (h + t) >> ;
                     if(SegTree_askrank(x, y, mid, root) +  <= z) h = mid + ;
                     else ans = mid, t = mid - ;
                 }
                 printf("%d\n", ans - );
                 break;
             }
             case :
             {
                 x = read();
                 z = read();
                 SegTree_change(x, z, root);
                 seq[x] = z;
                 maxn = max(maxn, z);
                 break;
             }
             case :
             {
                 x = read();
                 y = read();
                 z = read();
                 printf("%d\n", SegTree_findpre(x, y, z, root));
                 break;
             }
             case :
             {
                 x = read();
                 y = read();
                 z = read();
                 printf("%d\n", SegTree_findsuc(x, y, z, root));
                 break;
             }
         }
     }
     return ;
 }