[Tyvj 1730] 二逼平衡树

先来一发题面QwQ

[TYVJ1730]二逼平衡树

Time Limit：2 s   Memory Limit：512 MB

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

n,m<=50000   保证有序序列所有值在任何时刻满足[0,10^8]但是询问的数未必

这题正解似乎是树套树(线段树套平衡树)

然而我用分块大法水过去了233

分块的话思路还是比较明确的,比如对于求排名操作(操作1),对于两端的块我们可以选择直接暴力查询比$key$值小的值的个数,中间的完整块可以选择二分查找($std::lower\_bound$)来得出比$key$小的元素个数,累加起来加上1就是答案了.

求K大的话比较麻烦,要二分第K大的值然后用求排名操作来检验...

修改直接暴力修改不解释

前驱/后继则可以用上面求排名的方式来查找,不同的是对于比$key$小/大的元素不应累加而是求最大/小值.

然后就到了袋马时间~(突然感觉好草率啊QwQ)

GitHub:BlockSearch

#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

const int MAXN=50010;
const int MAXB=230;
const int INF=0x7FFFFFFF;

int n,m;
int endSize;
int blockNum;
int blockSize;
int data[MAXN];
int block[MAXN][MAXB];

void Initialize();
void FastRead(int&);
void Modify(int,int);
int Kth(int,int,int);
int Rank(int,int,int);
int Predecessor(int,int,int);
int Successor(int,int,int);

int main(){
    int opt,l,r,num;
    Initialize();
    for(int i=0;i<m;i++){
        scanf("%d",&opt);
        if(opt==1){
            FastRead(l);
            FastRead(r);
            FastRead(num);
            printf("%d
",Rank(l-1,r-1,num));
        }
        else if(opt==2){
            FastRead(l);
            FastRead(r);
            FastRead(num);
            printf("%d
",Kth(l-1,r-1,num));
        }
        else if(opt==3){
            FastRead(l);
            FastRead(num);
            Modify(l-1,num);
        }
        else if(opt==4){
            FastRead(l);
            FastRead(r);
            FastRead(num);
            printf("%d
",Predecessor(l-1,r-1,num));
        }
        else{
            FastRead(l);
            FastRead(r);
            FastRead(num);
            printf("%d
",Successor(l-1,r-1,num));
        }
    }
    return 0;
}

inline int Rank(int l,int r,int key){
    int lb=l/blockSize;
    int rb=r/blockSize;
    int ans=1;
    if(lb==rb){
        for(int i=l;i<=r;i++){
            if(data[i]<key){
                ans++;
            }
        }
    }
    else{
        for(int i=l;i<(lb+1)*blockSize;i++){
            if(data[i]<key){
                ans++;
            }
        }
        for(int i=rb*blockSize;i<=r;i++){
            if(data[i]<key){
                ans++;
            }
        }
        for(int i=lb+1;i<rb;i++){
            ans+=std::lower_bound(block[i],block[i]+blockSize,key)-block[i];
        }
    }
    return ans;
}

inline int Kth(int l,int r,int pos){
    int L=-1;
    int R=100000010;
    while(R-L>1){
        int mid=(L+R)>>1;
        if(Rank(l,r,mid)>pos)
            R=mid;
        else
            L=mid;
    }
    return R-1;
}

inline void Modify(int pos,int key){
    if(data[pos]==key)
        return;
    int* thisBlock=block[pos/blockSize];
    int old=data[pos];
    int size=(pos/blockSize)==blockNum?endSize:blockSize;
    data[pos]=key;
    pos=std::lower_bound(thisBlock,thisBlock+size,old)-thisBlock;
    thisBlock[pos]=key;
    std::sort(thisBlock,thisBlock+size);
}

inline int Predecessor(int l,int r,int key){
    int lb=l/blockSize;
    int rb=r/blockSize;
    int ans=-INF;
    if(lb==rb){
        for(int i=l;i<=r;i++){
            if(data[i]<key)
                ans=std::max(ans,data[i]);
        }
    }
    else{
        for(int i=l;i<(lb+1)*blockSize;i++){
            if(data[i]<key)
                ans=std::max(ans,data[i]);
        }
        for(int i=rb*blockSize;i<=r;i++){
            if(data[i]<key)
                ans=std::max(ans,data[i]);
        }
        for(int i=lb+1;i<rb;i++){
            int pos=std::lower_bound(block[i],block[i]+blockSize,key)-block[i];
            if(pos>0)
                ans=std::max(ans,block[i][pos-1]);
        }
    }
    return ans;
}

inline int Successor(int l,int r,int key){
    int lb=l/blockSize;
    int rb=r/blockSize;
    int ans=INF;
    if(lb==rb){
        for(int i=l;i<=r;i++)
            if(data[i]>key)
                ans=std::min(ans,data[i]);
    }
    else{
        for(int i=l;i<(lb+1)*blockSize;i++){
            if(data[i]>key)
                ans=std::min(ans,data[i]);
        }
        for(int i=rb*blockSize;i<=r;i++){
            if(data[i]>key)
                ans=std::min(ans,data[i]);
        }
        for(int i=lb+1;i<rb;i++){
            int pos=std::upper_bound(block[i],block[i]+blockSize,key)-block[i];
            if(pos<blockSize)
                ans=std::min(ans,block[i][pos]);
        }
    }
    return ans;
}

void Initialize(){
#ifndef ASC_LOCAL
    freopen("psh.in","r",stdin);
    freopen("psh.out","w",stdout);
#endif
    FastRead(n);
    FastRead(m);
    blockSize=sqrt(n);
    for(int i=0;i<n;i++){
        FastRead(data[i]);
        block[blockNum][endSize]=data[i];
        if(++endSize==blockSize){
            blockNum++;
            endSize=0;
        }
    }
    for(int i=0;i<blockNum;i++)
        std::sort(block[i],block[i]+blockSize);
    if(endSize!=0)
        std::sort(block[blockNum],block[blockNum]+endSize);
}

inline void FastRead(int& target){
    target=0;
    register char ch=getchar();
    bool neg=false;
    while(!isdigit(ch)){
        if(ch=='-')
            neg=true;
        ch=getchar();
    }
    while(isdigit(ch)){
        target=target*10+ch-'0';
        ch=getchar();
    }
    if(neg)
        target=-target;
}

然后图包时间233(拿图至少评论一下吼不吼哇QwQ)