[bzoj3196][Tyvj1730][主席树]二逼平衡树

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

1.n和m的数据范围：n,m<=50000

2.序列中每个数的数据范围：[0,1e8]

3.虽然原题没有，但事实上5操作的k可能为负数

题解

你看网上都是Treap套Treap啥的啊这么麻烦
有智慧的长者都写主席树
其实写这题主要是为了练一发带修主席树
前三个基本操作不说
后两个你可以找到他的排名，第一个找靠前那个，第二个找靠后那个
然后分别找排名-1或者+1的数
wa了一晚上还是静态差错有用= =

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
using namespace std;
inline void write(int x)
{
    if(!x) return (void)puts("0");
    if(x<0) putchar('-'),x=-x;
    static short s[25],t;
    while(x) s[++t]=x%10,x/=10; 
    while(t) putchar('0'+s[t--]);
    putchar('\n');
}
inline int read()
{
    int f=1,x=0;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline int lowbit(int x){return x&-x;}
struct LSnode{int y,p;}w[210000];int tt,cnt;
int n,m;
int gg[210000];
int fd(int pos)
{
    int l=1,r=tt;
    while(l<=r)
    {
        int mid=(l+r)/2;
        if(gg[mid]<pos)l=mid+1;
        else if(gg[mid]>pos)r=mid-1;
        else return mid;
    }
}
bool cmp(LSnode n1,LSnode n2){return n1.y<n2.y;}
struct node{int lc,rc,c;}tr[5110000];int tot;
void add(int &now,int l,int r,int p,int c)
{
    if(now==0)now=++tot;
    tr[now].c+=c;
    if(l==r)return ;
    int mid=(l+r)/2;
    if(p<=mid)add(tr[now].lc,l,mid,p,c);
    else add(tr[now].rc,mid+1,r,p,c);
}
int rt[210000];
void merge(int &x,int y)
{
    if(x==0){x=y;return ;}
    if(y==0)return ;
    tr[x].c+=tr[y].c;
    merge(tr[x].lc,tr[y].lc);
    merge(tr[x].rc,tr[y].rc);
}
int ust[110000];
void jump(int x,int op)
{
    while(x>n)
    {
        if(op==0)ust[x]=rt[x];
        else if(op==-1)ust[x]=tr[ust[x]].lc;
        else ust[x]=tr[ust[x]].rc;
        x-=lowbit(x);
    }
}
void change(int x,int p,int c)
{
    while(x<=2*n)
    {
        add(rt[x],1,tt,p,c);
        x+=lowbit(x);
    }
}
int findsum(int x)
{
    int ret=0;
    while(x>n)
    {
        ret+=tr[tr[ust[x]].lc].c;
        x-=lowbit(x);
    }
    return ret;
}
int findx(int x)
{
    int ret=0;
    while(x>n)
    {
        ret+=tr[ust[x]].c;
        x-=lowbit(x);
    }
    return ret;
}
int findRank(int x,int y,int px,int py,int l,int r,int p)
{
    if(l==r)return 1;
    int c=tr[tr[x].lc].c-tr[tr[y].lc].c+findsum(py+n)-findsum(px+n);
    int mid=(l+r)/2;
    if(p<=mid)
    {
        jump(py+n,-1);jump(px+n,-1);
        return findRank(tr[x].lc,tr[y].lc,px,py,l,mid,p);
    }
    else
    {
        jump(py+n,1);jump(px+n,1);
        return findRank(tr[x].rc,tr[y].rc,px,py,mid+1,r,p)+c;
    }
}
int findlow(int x,int y,int px,int py,int l,int r,int p)//有多少比p小的 
{
    if(l==r)return tr[x].c-tr[y].c+findx(py+n)-findx(px+n);
    int c=tr[tr[x].lc].c-tr[tr[y].lc].c+findsum(py+n)-findsum(px+n);
    int mid=(l+r)/2;
    if(p<=mid)
    {
        jump(py+n,-1);jump(px+n,-1);
        return findlow(tr[x].lc,tr[y].lc,px,py,l,mid,p);
    }
    else
    {
        jump(py+n,1);jump(px+n,1);
        return findlow(tr[x].rc,tr[y].rc,px,py,mid+1,r,p)+c;
    }
}
int findcal(int x,int y,int px,int py,int l,int r,int K)
{
    if(l==r)return gg[l];
    int c=tr[tr[x].lc].c-tr[tr[y].lc].c+findsum(py+n)-findsum(px+n);
    int mid=(l+r)/2;
    if(K<=c)
    {
        jump(py+n,-1);jump(px+n,-1);
        return findcal(tr[x].lc,tr[y].lc,px,py,l,mid,K);
    }
    else
    {
        jump(py+n,1);jump(px+n,1);
        return findcal(tr[x].rc,tr[y].rc,px,py,mid+1,r,K-c);
    }
}
struct ask{int op,l,r,k;}A[210000];
int Rank[210000];
int main()
{
    n=read(),m=read();
    for(int i=1;i<=n;i++)w[i].y=read(),w[i].p=i;cnt=n;
    for(int i=1;i<=m;i++)
    {
        A[i].op=read();
        if(A[i].op==3)A[i].l=read(),A[i].k=read();
        else A[i].l=read(),A[i].r=read(),A[i].k=read();
        w[++cnt].y=A[i].k;
    }
    sort(w+1,w+1+cnt,cmp);
    tt=0;
    for(int i=1;i<=cnt;i++)
    {
        if((w[i].y!=w[i-1].y) ||(i==1))tt++;
        if(w[i].p!=0)Rank[w[i].p]=tt;
        gg[tt]=w[i].y;
    }
    for(int i=1;i<=n;i++)add(rt[i],1,tt,Rank[i],1);
    for(int i=2;i<=n;i++)merge(rt[i],rt[i-1]);
    for(int i=1;i<=m;i++)
    {
        if(A[i].op==1)
        {
            jump(A[i].l-1+n,0);jump(A[i].r+n,0);
            write(findRank(rt[A[i].r],rt[A[i].l-1],A[i].l-1,A[i].r,1,tt,fd(A[i].k)));
        }
        else if(A[i].op==2)
        {
            jump(A[i].l-1+n,0);jump(A[i].r+n,0);
            write(findcal(rt[A[i].r],rt[A[i].l-1],A[i].l-1,A[i].r,1,tt,A[i].k));
        }
        else if(A[i].op==3)
        {
            change(A[i].l+n,Rank[A[i].l],-1);
            Rank[A[i].l]=fd(A[i].k);
            change(A[i].l+n,Rank[A[i].l],1);
        }
        else if(A[i].op==4)
        {
            jump(A[i].l-1+n,0);jump(A[i].r+n,0);
            int tmp=findRank(rt[A[i].r],rt[A[i].l-1],A[i].l-1,A[i].r,1,tt,fd(A[i].k));
            jump(A[i].l-1+n,0);jump(A[i].r+n,0);
            write(findcal(rt[A[i].r],rt[A[i].l-1],A[i].l-1,A[i].r,1,tt,tmp-1));
        }
        else
        {
            if(A[i].k>=0)
            {
                jump(A[i].l-1+n,0);jump(A[i].r+n,0);
                int tmp=findlow(rt[A[i].r],rt[A[i].l-1],A[i].l-1,A[i].r,1,tt,fd(A[i].k));
                jump(A[i].l-1+n,0);jump(A[i].r+n,0);
                write(findcal(rt[A[i].r],rt[A[i].l-1],A[i].l-1,A[i].r,1,tt,tmp+1)); 
            }
            else 
            {
                jump(A[i].l-1+n,0);jump(A[i].r+n,0);
                write(findcal(rt[A[i].r],rt[A[i].l-1],A[i].l-1,A[i].r,1,tt,1));
            }
        }
    }
    return 0;
}