[模板]洛谷T3380 二逼平衡树 线段树套BST

时隔一个月后，终于攻克了二分求K大的难题。。。特此纪念 2017.10.3

好好的树套树模板题怎么没有一份线段树套平衡树的“标准”题解呢。。。虽然这方法比较low，但我还是来贴一发。。。

据说这题常数巨大，若干份线段树套BST的代码都被卡常了

萌新我看到这吓人的通过率不由瑟瑟发抖

于是使出浑身解数，用了一大堆奇技淫巧进行疯狂的常数优化。。。

然后。。。居然没被卡到。。。滑稽。。。

进入正题：

何为树套树？

考虑这题要求的操作。区间操作要求使用线段树，求排名、K大什么的又要求使用BST，所以就可以祭出线段树套BST了，具体是指，在线段树划定的每个区间上都分别建立一棵BST。这样，空间复杂度就是线段树的宽×高，即为nlogn。

这样操作，就将原先的一段区间分成了logn棵BST。对每个BST操作后，将结果合并即得答案。显然，这样一次操作的时间复杂度是log^2n。

操作解析：

每次操作先由线段树自顶向下查询，若当前线段树区间完全包含于待操作区间，则在本区间所属的BST内进行相应的平衡树操作并返回结果，全部操作结束后将所有结果合并即可。

对于操作1：在每个BST内查询严格小于k的数的个数，将所有结果相加再加1即为答案。

对于操作2：

先吐槽一句。。。就是这个操作，折磨了我一个月之久。。。二分的细节什么的太恶心。。。

对于树套树，这个操作貌似是无法直接实现的，因为区间并不是有序的QwQ

那么要怎么搞呢？答案是二分，每次对二分出的值查询一次区间排名，不断逼近给定的k即可。

但是，由于元素重复等等的原因，使得这个二分过程难以实现。。。

这里对代码中的二分细节作一下解释：

1.x的计算紧跟在l和r的变动之后，目的是使这三个值保持同步，保证结果准确；

2.如果x的排名>k，联系求排名操作的性质，可推知这时的x一定大于结果，那么就将x以及比x大的值都排除，故有r=x-1。通过类似推理可得，当x的排名<=k时，须执行l=x；

3.x的计算问题。

如果写成x=(l+r)>>1，那么在某些情况下会死循环。原因如下：

当l+1==r且对l查询满足其排名<=k时，按照(l+r)>>1计算的x等于l，那么会导致执行l=x，然而原本就有l==x。。。于是就死循环了~

写成x=(l+r+1)>>1的作用是，让x偏向于r，这样，在发生上述情况时，会有如下变动：

x=(l+r+1)>>1=r，当x的排名>k，那么执行r=x-1=l；当x的排名<=k，那么执行l=x=r。无论如何，都将得到l==r而退出循环，而不是死循环。

如此便能解决问题。

对于操作3：首先在原序列中找到pos位置原先的值，然后在每个BST中将该值删除再插入k即可。注意也要修改原序列中的值，以便下一次操作3时使用。

对于操作4：在每个BST内求一次前驱，最后对所有结果取一次Max即可。

对于操作5：与操作4同理。

下面讲一下我的“奇技淫巧”。。。

对于线段树套BST，因为线段树的结构稳定，所以BST就在很大程度上决定了代码的性能如何。

那么选择怎样的BST呢？每次都进行暴力单点插入？不行不行，会被卡常。。。

NOI2005 维护数列 这道题告诉我，建立完全平衡的BST，其性能远优于上面的方法。这样做，不仅建树速度快，而且对于提升后续操作的性能效果明显。

但是，建立完全平衡的BST，需要序列有序，然而这里的序列是无序的。

每次都排序一下？不行不行，时间更会炸掉。。。

这时我想，能不能让当前排序后的序列，方便上层序列的排序，从而减少时间消耗呢？

突然我回想起归并排序的性质。。。没错！对于建树的过程，整体嵌入一个归并，便可达到目的，建立起完全平衡的BST。

“奇技淫巧”细节详见代码。

代码如下：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdlib>

#include<string>
#include<stack>
#include<queue>
#include<vector>
#include<algorithm>
#include<map>
#include<set>

#define inf 2147483647

using namespace std;

inline void read(int &x){  //读入优化 
    x=0;
    char t=getchar();
    bool f=0;
    
    while(t<'0' || t>'9'){
        if(t=='-')f=1;
        t=getchar();
    }
    
    while(t>='0' && t<='9'){
        x=(x<<3)+(x<<1)+t-'0';
        t=getchar();
    }
    
    if(f)x=-x;
}

struct xb{  //合并重复后的待建节点 
    int v,num;
};

int c[100010];  //原序列
xb yby[100010];  //合并后的待建序列 
int temp[100010];  //排序用辅助序列
int longtao[100010];  //归并用辅助序列

int rank_ans;
int pre_ans,succ_ans;
int k,l,r;

int n,m,i;
int opt,a,b,pos,x;

void merge(int,int,int);  //归并 

struct node{  //平衡树节点定义 
    int key;
    int size,num;
    node *ch[2];
    
    void make(int x){  //新建节点，x为下标，指向待建节点 
        key=yby[x].v;
        size=num=yby[x].num;
        ch[0]=ch[1]=NULL;
    }
    
    void maintain(){
        size=num;
        if(ch[0]!=NULL)size+=ch[0]->size;
        if(ch[1]!=NULL)size+=ch[1]->size;
    }
};

void rotate(node* &,bool);  //旋转 
void insert(node* &,int);  //插入 
void del(node* &,int);  //删除 
void unit(int,int,node* &);  //合并待建序列中的重复元素 
void bst_build(node* &,int,int,int);  //平衡树建树 
int bst_rank(node *,int);  //求排名 
void bst_pre(node *,int);  //求前驱 
void bst_succ(node *,int);  //求后继 

struct sgt{  //线段树 
    node *p[200010];
    
    void build(int o,int l,int r){
        int mid=(l+r)>>1;
        
        if(l<r){
            int lson=o<<1;
            int rson=lson|1;
            
            build(lson,l,mid);
            build(rson,mid+1,r);
        }
        
        merge(l,r,mid);
        
        p[o]=NULL;
        unit(l,r,p[o]);
    }
    
    void rank(int o,int l,int r){
        if(l>=a && r<=b)rank_ans+=bst_rank(p[o],x)-1;
        
        else{
            int mid=(l+r)>>1;
            int lson=o<<1;
            int rson=lson|1;
            
            if(a<=mid)rank(lson,l,mid);
            if(b>mid)rank(rson,mid+1,r);
        }
    }
    
    void update(int o,int l,int r){
        del(p[o],c[pos]);
        insert(p[o],x);
        
        if(l<r){
            int mid=(l+r)>>1;
            int lson=o<<1;
            int rson=lson|1;
            
            if(pos<=mid)update(lson,l,mid);
            else update(rson,mid+1,r);
        }
    }
    
    void pre(int o,int l,int r){
        if(l>=a && r<=b)bst_pre(p[o],x);
        
        else{
            int mid=(l+r)>>1;
            int lson=o<<1;
            int rson=lson|1;
            
            if(a<=mid)pre(lson,l,mid);
            if(b>mid)pre(rson,mid+1,r);
        }
    }
    
    void succ(int o,int l,int r){
        if(l>=a && r<=b)bst_succ(p[o],x);
        
        else{
            int mid=(l+r)>>1;
            int lson=o<<1;
            int rson=lson|1;
            
            if(a<=mid)succ(lson,l,mid);
            if(b>mid)succ(rson,mid+1,r);
        }
    }
} tree;

int main(){
    srand(time(0));
    
    read(n);read(m);
    
    for(i=1;i<=n;i++){
        read(c[i]);
        temp[i]=c[i];
    }
    
    tree.build(1,1,n);
    
    for(i=1;i<=m;i++){
        read(opt);
        
        switch(opt){
            case 1:{
                read(a);read(b);read(x);
                
                rank_ans=1;
                tree.rank(1,1,n);
                printf("%d
",rank_ans);
                break;
            }
            
            case 2:{
                read(a);read(b);read(k);
                
                l=0;
                r=100000000;
                x=(l+r+1)>>1;
                
                while(l<r){
                    rank_ans=1;
                    tree.rank(1,1,n);
                    
                    if(rank_ans>k)r=x-1;
                    else l=x;
                    
                    x=(l+r+1)>>1;
                }
                
                printf("%d
",x);
                break;
            }
            
            case 3:{
                read(pos);read(x);
                
                tree.update(1,1,n);
                c[pos]=x;
                break;
            }
            
            case 4:{
                read(a);read(b);read(x);
                
                pre_ans=-inf;
                tree.pre(1,1,n);
                printf("%d
",pre_ans);
                break;
            }
            
            case 5:{
                read(a);read(b);read(x);
                
                succ_ans=inf;
                tree.succ(1,1,n);
                printf("%d
",succ_ans);
                break;
            }
        }
    }
    
    return 0;
} 

void rotate(node* &p,bool f){
    node *t=p->ch[f^1];
    p->ch[f^1]=t->ch[f];
    t->ch[f]=p;
    
    p->maintain();
    t->maintain();
    
    p=t;
}

void insert(node* &p,int x){
    if(p==NULL){
        p=(node *)malloc(sizeof(node));
        p->key=x;
        p->size=p->num=1;
        p->ch[0]=p->ch[1]=NULL;
        return;
    }
    
    if(x==p->key){
        p->size++;
        p->num++;
        return;
    }
    
    if(x<p->key){
        insert(p->ch[0],x);
        p->size++;
    }
    else{
        insert(p->ch[1],x);
        p->size++;
    }
}

void del(node* &p,int x){
    if(p==NULL)return;
    
    if(x==p->key){
        if(p->num>1){
            p->num--;
            p->size--;
            return;
        }
        else{
            if(p->ch[0]==NULL){
                node* t=p;
                p=p->ch[1];
                free(t);
                return;
            }
            else if(p->ch[1]==NULL){
                node* t=p;
                p=p->ch[0];
                free(t);
                return;
            }
            else{
                bool f=rand()&1;
                rotate(p,f);
                del(p->ch[f],x);
                p->size--;
            }
        }
    }
    else{
        if(x<p->key)del(p->ch[0],x);
        else del(p->ch[1],x);
        p->size--;
    }
}

void unit(int l,int r,node* &root){
    int i;
    int p_yby=1;
    
    yby[1].v=temp[l];
    yby[1].num=1;
    
    for(i=l+1;i<=r;i++){
        if(temp[i]==yby[p_yby].v)yby[p_yby].num++;
        else{
            p_yby++;
            yby[p_yby].v=temp[i];
            yby[p_yby].num=1;
        }
    }
    
    bst_build(root,1,p_yby,(1+p_yby)>>1);
}

void bst_build(node* &p,int l,int r,int mid){
    p=(node *)malloc(sizeof(node));
    p->make(mid);
    
    if(mid-1>=l)bst_build(p->ch[0],l,mid-1,(l+mid-1)>>1);
    if(mid+1<=r)bst_build(p->ch[1],mid+1,r,(mid+1+r)>>1);
    
    p->maintain();
}

int bst_rank(node *p,int x){
    if(p==NULL)return 1;
    
    int s=0;
    if(p->ch[0]!=NULL)s=p->ch[0]->size;
    
    if(x<p->key)return bst_rank(p->ch[0],x);
    else if(x==p->key)return s+1;
    else return s+p->num+bst_rank(p->ch[1],x);
}

void merge(int head,int tail,int mid){
    if(head==tail)return;
    
    int p1=head,p2=mid+1,ph=head;
    
    while(p1<=mid && p2<=tail){
        if(temp[p1]<temp[p2]){
            longtao[ph]=temp[p1];
            p1++;
            ph++;
        }
        else{
            longtao[ph]=temp[p2];
            p2++;
            ph++;
        }
    }
    
    while(p1<=mid){
        longtao[ph]=temp[p1];
        p1++;
        ph++;
    }
    
    while(p2<=tail){
        longtao[ph]=temp[p2];
        p2++;
        ph++;
    }
    
    for(i=head;i<=tail;i++)temp[i]=longtao[i];
}

void bst_pre(node *p,int x){
    if(p==NULL)return;
    if(p->key<x){
        pre_ans=max(pre_ans,p->key);
        bst_pre(p->ch[1],x);
    }
    else bst_pre(p->ch[0],x);
}

void bst_succ(node *p,int x){
    if(p==NULL)return;
    if(p->key>x){
        succ_ans=min(succ_ans,p->key);
        bst_succ(p->ch[0],x);
    }
    else bst_succ(p->ch[1],x);
}