[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 = 3500001, INF = 2147483647;

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

inline int read()
{
    int f = 1, x = 0;
    char ch = getchar();
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
    for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
    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 = 0;
}

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]][1] == x;
}

inline void Splay_rotate(int x)
{
    int old = f[x], oldf = f[old], wh = Splay_get(x);
    
    son[old][wh] = son[x][wh ^ 1];
    f[son[old][wh]] = old;
    
    son[x][wh ^ 1] = old;
    f[old] = x;
    
    if(oldf) son[oldf][son[oldf][1] == 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 = 0;
    if(!rt[x])
    {
        rt[x] = ++sz;
        key[sz] = k;
        size[sz] = cnt[sz] = 1;
        return;
    }
    while(1)
    {
        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] = 1;
            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 = 0;
    while(1)
    {
        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(1)
    {
        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]][0];
    while(rs) now = rs;
    return now;
}

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

inline void Splay_del(int x)
{
    int now = rt[x];
    if(cnt[now] > 1)
    {
        cnt[now]--;
        Splay_update(now);
        return;
    }
    if(!ls && !rs)
    {
        rt[x] = 0;
        Splay_clear(now);
        return;
    }
    if(!ls || !rs)
    {
        rt[x] = ls + rs;
        f[rt[x]] = 0;
        Splay_clear(now);
        return;
    }
    int pre = Splay_pre(x);
    Splay_splay(pre);
    rt[x] = pre;
    son[pre][1] = 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) >> 1;
    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 0;
    int mid = (l + r) >> 1;
    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) >> 1;
    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) >> 1;
    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) >> 1;
    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 = 0;
    n = read();
    m = read();
    for(i = 1; i <= n; i++) seq[i] = read(), maxn = max(maxn, seq[i]), SegTree_insert(i, seq[i], root);
    for(i = 1; i <= m; i++)
    {
        opt = read();
        switch(opt)
        {
            case 1:
            {
                x = read();
                y = read();
                z = read();
                printf("%d
", SegTree_askrank(x, y, z, root) + 1);
                break;
            }
            case 2:
            {
                x = read();
                y = read();
                z = read();
                h = 0, t = maxn;
                while(h <= t)
                {
                    mid = (h + t) >> 1;
                    if(SegTree_askrank(x, y, mid, root) + 1 <= z) h = mid + 1;
                    else ans = mid, t = mid - 1;
                }
                printf("%d
", ans - 1);
                break;
            }
            case 3:
            {
                x = read();
                z = read();
                SegTree_change(x, z, root);
                seq[x] = z;
                maxn = max(maxn, z);
                break;
            }
            case 4:
            {
                x = read();
                y = read();
                z = read();
                printf("%d
", SegTree_findpre(x, y, z, root));
                break;
            }
            case 5:
            {
                x = read();
                y = read();
                z = read();
                printf("%d
", SegTree_findsuc(x, y, z, root));
                break;
            }
        }
    }
    return 0;
}