洛谷 P3380 【模板】二逼平衡树（树套树） 题解

题目传送门

题目大意： 唉好长啊不写了qwq

这就是个待修主席树的板子，没啥好讲的。

当然各位大佬还有很多神奇的做法，但是我太蒟蒻了，介绍不起。

对于前三个操作都是待修主席树的基操，后面两个求前驱后继操作也可以利用前两个操作得到，显然 $x$ 在区间 $[l,r]$ 内的后继（或前驱）的排名一定比 $x$ 的排名大 $1$ （或小 $1$），所以求出 $x$ 在区间 $[l,r]$ 内的排名然后 $+1/-1$ 一下，再求出区间 $[l,r]$ 内排名为 $x+1/-1$ 的那个数即可。

还要注意，待修主席树在值域很大的时候动态开点的时空消耗都很大，所以这题需要离散化。就是因为没离散化我MLE了半天……

然后，因为离散化，所以要把大量的数给转成它离散化之后对应的数，这个转换我只能想到用 $map$ 来实现（$hash$ 太麻烦而且正确性难以保证，保证了正确性时空及代码复杂度又会很高，所以懒得打），然后……TLE了三个点QAQ。

但是，$stl$ 里面的东西吸口氧之后都能跟打了鸡血似的，所以开一个 $O2$ 之后最慢的点不过 $1s$。

还要注意，操作 $1、4、5$ 询问的数可能不在这个区间内。

代码如下（有详细注释）：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
#define maxn 100010
#define inf 200000

int n,m,a[maxn];
struct node{
    int z;//表示管理区间内的数的出现次数
    node *zuo,*you;//左右儿子
    node():z(0),zuo(NULL),you(NULL){}
};
node *root[maxn];
inline int lowbit(int x){return x&(-x);}
void change(node *&x,int y,int z,int l,int r)
//参数意义：x：当前的根，[l,r]：x的管理区间，y&z：表示将区间中第y位+z
{
    if(x==NULL)x=new node();
    x->z+=z;
    if(l==r)return;
    int mid=l+r>>1;
    if(y<=mid)change(x->zuo,y,z,l,mid);
    else change(x->you,y,z,mid+1,r);
}
int sum(node *now,int x,int y,int l,int r)//找到now的子树中管理区间[x,y]的那个儿子的值，[l,r]表示当前now的管理区间
{
    if(now==NULL)return 0;
    if(l==x&&r==y)return now->z;
    int mid=l+r>>1;
    if(y<=mid)return sum(now->zuo,x,y,l,mid);
    else return sum(now->you,x,y,mid+1,r);
}
int getsum(int x,int y,int l,int r)
//求出序列中区间[x+1,y]里面有多少个在[l,r]区间内的数
{
    int re=0;
    for(int i=y;i>=1;i-=lowbit(i))
    re+=sum(root[i],l,r,0,inf);
    for(int i=x;i>=1;i-=lowbit(i))
    re-=sum(root[i],l,r,0,inf);
    return re;
}
int ask(int z,int l,int r,int ll,int rr)
//求出z在序列的区间[ll,rr]中的排名，[l,r]表示现在在主席树中管理[l,r]区间的节点上
{
    if(l==r)return 1;
    int mid=l+r>>1;
    if(z<=mid)return ask(z,l,mid,ll,rr);
    else return getsum(ll,rr,l,mid)+ask(z,mid+1,r,ll,rr);
}
int askkth(int z,int l,int r,int ll,int rr)//找到排名为z的数，其他参数和上面的相似
{
    if(l==r)return l;
    int mid=l+r>>1,zuosum=getsum(ll,rr,l,mid);
    if(z<=zuosum)return askkth(z,l,mid,ll,rr);
    else return askkth(z-zuosum,mid+1,r,ll,rr);
}
struct que{int id,x,y,z;};
que Ask[maxn];//记录下所有询问
int now[maxn],cnt=0;//now记录所有需要离散化的数
map<int,int>mp;
int pre(int x,int y,int z)//求z在[x,y]区间内的前驱
{
	int rank=ask(z,0,inf,x-1,y);//找到z的排名
	rank--;//排名-1
	if(rank==0)return cnt-1;//注意判断无解
	return askkth(rank,0,inf,x-1,y);//求出前驱，就是[x,y]区间内第rank大的数
}
int nxt(int x,int y,int z)
{
	int rank=ask(z,0,inf,x-1,y);
	if(askkth(rank,0,inf,x-1,y)==z)rank++;
	//注意求后继时需要判断，因为[x,y]区间内可能没有z这个数，如果没有的话rank就不用+1了
	//前驱不需要判，原因自己思考一下就能明白
	if(rank==y-x+2)return cnt;
	return askkth(rank,0,inf,x-1,y);
}

int main()
{
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++)
    scanf("%d",&a[i]),now[++cnt]=a[i];//记录下需要离散化的数
    for(int i=1;i<=m;i++)
    {
    	scanf("%d %d %d",&Ask[i].id,&Ask[i].x,&Ask[i].y);
    	if(Ask[i].id!=3)
    	{
    		scanf("%d",&Ask[i].z);
    		if(Ask[i].id!=2)now[++cnt]=Ask[i].z;
    	}
    	else now[++cnt]=Ask[i].y;//同样是记录下需要离散化的数
    }
    sort(now+1,now+cnt+1);cnt=unique(now+1,now+cnt+1)-now-1;
    //排序去重
    for(int i=1;i<=cnt;i++)
    mp[now[i]]=i;//记录每个数离散化之后的值
    now[++cnt]=-2147483647;//求前驱后继时用到
    now[++cnt]=2147483647;
    for(int i=1;i<=n;i++)
    for(int j=i;j<=n;j+=lowbit(j))
    change(root[j],mp[a[i]],1,0,inf);//先把一开始的主席树建出来
    for(int i=1;i<=m;i++)
    {
    	int x=Ask[i].x,y=Ask[i].y,z=Ask[i].z;
        switch(Ask[i].id)
        {
            case 1:
                printf("%d\n",ask(mp[z],0,inf,x-1,y));
                break;
            case 2:
                printf("%d\n",now[askkth(z,0,inf,x-1,y)]);
                break;
            case 3:
                for(int j=x;j<=n;j+=lowbit(j))
                change(root[j],mp[a[x]],-1,0,inf);
                a[x]=y;
                for(int j=x;j<=n;j+=lowbit(j))
                change(root[j],mp[a[x]],1,0,inf);
                break;
            case 4:
                printf("%d\n",now[pre(x,y,mp[z])]);
                break;
            case 5:
                printf("%d\n",now[nxt(x,y,mp[z])]);
                break;
        }
    }
}