BZOJ[3196]Tyvj 1730 二逼平衡树 树套树

题目链接

线段树套平衡树
对于opt=1，在每个区间找出所有比k小的数，求和+1即为k的排名
对于opt=2，二分排名为k的值，如果该数存在的话答案就是这个数，不存在答案则为它的前驱
对于opt=3，在平衡树上删除再添加即可
对于opt=4，5，每段区间找一个，求他们的max/min即可

这里套的是Splay

一些细节：

对于Splay删除操作，我询问了一些dalao的做法，这里选择了一个比较高效的，即将它的前驱Splay到根，他的后继Splay到根的右儿子，直接操掉根右儿子的左儿子即可

插入过程中，要在插入结束将插入的点Splay到根，维护平衡性，在Insert没递归结束会导致回溯出错，这里写了个AddNew函数，过程是插入->旋转，保证Splay操作是在回溯结束后

在Splay时根的指针可能出现混乱，我采用了比较傻逼的方式，传参数的时候加一个x1代表是哪个线段树的节点，Splay结束后直接更新就好(可能会有更方便的方法吧…)
具体操作：
1.找出这个点的前驱后继，如果都不为空就直接日右儿子的左儿子
2.如果前驱为空，代表这个数就是最小的了，把它的后继转到根，日掉根的左儿子
3.如果后继为空，代表这个数是最大的，把它的前驱转到根，日掉根的右儿子
4.日掉就是看这个点代表数的个数是否大于1，大于1就直接减掉一个，否则把它赋成null

对于4,5操作的前驱后继，要的是值，对Delete操作求的前驱后继，要的是指针
虽然本人尝试过把求指针和值的函数写成一个，但是在线段树统计的时候会出现问题，变得更麻烦
所以感觉还是这么分开写比较方便…

代码看起来麻烦，但思路清晰的话还是挺好写的(一些函数互相Copy就OK23333)

代码如下：

#include<algorithm>
#include<ctype.h>
#include<cstdio>
#define N 50020
using namespace std;
const int INF=100000000;
inline int read(){
    int x=0,f=1;char c;
    do c=getchar(),f=c=='-'?-1:f; while(!isdigit(c));
    do x=(x<<3)+(x<<1)+c-'0',c=getchar(); while(isdigit(c));
    return x*f;
}
struct Node{
    Node *ch[2],*fa;
    int siz,cnt,x;
    Node(int);
    inline void maintain(){
        siz=cnt+ch[0]->siz+ch[1]->siz;
        return;
    }
    inline int dir(){
        if(fa->ch[0]==this) return 0;
        if(fa->ch[1]==this) return 1;
        return -1;
    }
    inline int cmp(int k){
        if(x==k) return -1;
        return k<x?0:1;
    }
}*null,*tmp;
struct SNode{
    int l,r;
    SNode *ls,*rs;
    Node *Splay;
    SNode():Splay(null){}
}*Seg_Root;
Node::Node(int _):x(_){
    siz=cnt=1;
    ch[0]=ch[1]=fa=null;
}
inline void init(){///预处理null和线段树的根
    null=new Node(-1);
    null->ch[0]=null->ch[1]=null->fa=null;
    null->siz=null->cnt=0;
    Seg_Root=new SNode;Seg_Root->Splay=null;
}
void print(Node *x){///Debug
    if(x==null) return;
    printf("%d  ",x->x);
    print(x->ch[0]);
    print(x->ch[1]);
}
void print1(Node *x){///Debug-First
    if(x==null) return;
    print1(x->ch[0]);
    printf("%d ",x->x);
    print1(x->ch[1]);
}
int n,m,t,l,r,k;
int a[N];
inline void Rotate(Node *x,int d){
    Node *k=x->ch[d^1];
    x->ch[d^1]=k->ch[d];
    if(x->ch[d^1]!=null) x->ch[d^1]->fa=x;
    k->ch[d]=x;
    if(x->fa!=null) x->fa->ch[x->dir()]=k;
    k->fa=x->fa;x->fa=k;
    x->maintain();k->maintain();
}
inline void Splay(Node *x,Node *y,SNode *x1){///Splay x 到 y 的儿子上，x1代表在那个线段树上(用于更新根)
    while(x->fa!=y){
        if(x->fa->fa!=y && x->fa->fa!=null)
            if(x->dir()==x->fa->dir())
                Rotate(x->fa->fa,x->dir()^1);
        Rotate(x->fa,x->dir()^1);
    }
    x->maintain();
    if(y==null) x1->Splay=x;///更新根
}
void Insert(Node *&x,int k,Node *fa){
    if(x==null){
        x=new Node(k);
        x->fa=fa;tmp=x;
        return;
    }
    int d=x->cmp(k);
    if(!~d){
        x->cnt++;x->siz++;
        tmp=x;
    }
    else{
        Insert(x->ch[d],k,x);
        x->maintain();
    }
}
inline void AddNew(int k,SNode *t){
    Insert(t->Splay,k,null);
    Splay(tmp,null,t);///tmp存你这个值放到了哪个点上
}
int Rank(Node *x,int k){///排名
    if(x==null) return 0;
    int d=x->cmp(k);
    if(!~d) return x->ch[0]->siz;
    return Rank(x->ch[d],k)+(d?x->ch[0]->siz+x->cnt:0);
}
bool Find(Node *x,int k){///数k有没有出现过
    if(x==null) return false;
    int d=x->cmp(k);
    if(!~d) return true;
    return Find(x->ch[d],k);
}
int Lower(Node *x,int k){///数k的前驱
    if(x==null) return -INF;
    if(x->x>=k) return Lower(x->ch[0],k);
    return max(x->x,Lower(x->ch[1],k));
}
int Upper(Node *x,int k){///数k的后继
    if(x==null) return INF;
    if(x->x<=k) return Upper(x->ch[1],k);
    return min(x->x,Upper(x->ch[0],k));
}
Node* LowerPointer(Node *x,int k){///数k的前驱(指针)
    if(x==null) return null;
    if(x->x>=k) return LowerPointer(x->ch[0],k);
    Node *t=LowerPointer(x->ch[1],k);
    return t==null?x:t;
}
Node* UpperPointer(Node *x,int k){///数k的后继(指针)
    if(x==null) return null;
    if(x->x<=k) return UpperPointer(x->ch[1],k);
    Node *t=UpperPointer(x->ch[0],k);
    return t==null?x:t;
}
void maketree(int l,int r,SNode *x){
    x->l=l;x->r=r;
    for(int i=l;i<=r;i++) AddNew(a[i],x);///建树时把每个点暴力插入
    if(l==r) return;
    int mid=l+r>>1;
    maketree(l,mid,x->ls=new SNode);maketree(mid+1,r,x->rs=new SNode);
}
int Query_Rank(int x,int y,int v,SNode *k){///SegmentTree Rank
    if(k->l>=x && k->r<=y){
        return Rank(k->Splay,v);
    }
    int mid=k->l+k->r>>1;
    if(mid>=y) return Query_Rank(x,y,v,k->ls);
    else if(mid<x) return Query_Rank(x,y,v,k->rs);
    else return Query_Rank(x,y,v,k->ls)+Query_Rank(x,y,v,k->rs);
}
bool Query_Find(int x,int y,int v,SNode *k){///SegmentTree Find
    if(k->l>=x && k->r<=y){
        return Find(k->Splay,v);
    }
    int mid=k->l+k->r>>1;
    if(mid>=y) return Query_Find(x,y,v,k->ls);
    else if(mid<x) return Query_Find(x,y,v,k->rs);
    else return Query_Find(x,y,v,k->ls)|Query_Find(x,y,v,k->rs);
}
int Query_Lower(int x,int y,int v,SNode *k){///SegmentTree Lower
    if(k->l>=x && k->r<=y){
        return Lower(k->Splay,v);
    }
    int mid=k->l+k->r>>1;
    if(mid>=y) return Query_Lower(x,y,v,k->ls);
    else if(mid<x) return Query_Lower(x,y,v,k->rs);
    else return max(Query_Lower(x,y,v,k->ls),Query_Lower(x,y,v,k->rs));
}
int Query_Upper(int x,int y,int v,SNode *k){///SegmentTree Upper
    if(k->l>=x && k->r<=y){
        return Upper(k->Splay,v);
    }
    int mid=k->l+k->r>>1;
    if(mid>=y) return Query_Upper(x,y,v,k->ls);
    else if(mid<x) return Query_Upper(x,y,v,k->rs);
    else return min(Query_Upper(x,y,v,k->ls),Query_Upper(x,y,v,k->rs));
}
inline void Solve1(int x,int y,int k){
    int l=0,r=INF,tmp;
    while(l<=r){
        int mid=l+r>>1;
        int t=Query_Rank(x,y,mid,Seg_Root)+1;
        if(t>k) r=mid-1;
        else tmp=mid,l=mid+1;
    }
    if(Query_Find(x,y,tmp,Seg_Root)) printf("%d\n",tmp);
    else printf("%d\n",Query_Lower(x,y,tmp,Seg_Root));
}//SubTask2
inline void Delete(SNode *x,int k){///删除
    Node *a=LowerPointer(x->Splay,k),*b=UpperPointer(x->Splay,k);
    if(a==null && b==null){
        if(x->Splay->cnt>1) x->Splay->cnt--,x->Splay->siz--;
        else x->Splay=null;
        return;
    }
    if(a==null){
        Splay(b,null,x);
        if(x->Splay->ch[0]->cnt>1){
            x->Splay->ch[0]->cnt--;
            x->Splay->ch[0]->siz--;
            x->Splay->maintain();
        }
        else{
            x->Splay->ch[0]=null;
            x->Splay->maintain();
        }
        return;
    }
    if(b==null){
        Splay(a,null,x);
        if(x->Splay->ch[1]->cnt>1){
            x->Splay->ch[1]->cnt--;
            x->Splay->ch[1]->siz--;
            x->Splay->maintain();
        }
        else{
            x->Splay->ch[1]=null;
            x->Splay->maintain();
        }
        return;
    }///特判三种情况
    Splay(a,null,x);
    Splay(b,a,x);
    if(x->Splay->ch[1]->ch[0]->cnt>1){
        x->Splay->ch[1]->ch[0]->cnt--;
        x->Splay->ch[1]->ch[0]->siz--;
        x->Splay->ch[1]->maintain();
        x->Splay->maintain();
    }
    else{
        x->Splay->ch[1]->ch[0]=null;
        x->Splay->ch[1]->maintain();
        x->Splay->maintain();
    }
}
inline void Modify(int x,int v,SNode *k){
    Delete(k,a[x]);
    AddNew(v,k);
    if(k->l==k->r) return;
    int mid=k->l+k->r>>1;
    if(x<=mid) Modify(x,v,k->ls);
    else Modify(x,v,k->rs);
}
int main(){
    init();
    n=read();m=read();
    for(int i=1;i<=n;i++)
        a[i]=read();
    maketree(1,n,Seg_Root);
    for(int i=1;i<=m;i++){
        t=read();
        switch(t){
            case 1: l=read(); r=read(); k=read(); printf("%d\n",Query_Rank(l,r,k,Seg_Root)+1); break;
            case 2: l=read(); r=read(); k=read(); Solve1(l,r,k); break;
            case 3: l=read(); k=read(); Modify(l,k,Seg_Root); a[l]=k; break;
            case 4: l=read(); r=read(); k=read(); printf("%d\n",Query_Lower(l,r,k,Seg_Root)); break;
            case 5: l=read(); r=read(); k=read(); printf("%d\n",Query_Upper(l,r,k,Seg_Root)); break;
        }
    }
return 0;
}