20200223 专题：树套树

总览：

恶心
字面意思，数据结构套数据结构。码量超大，细节超多，调到死

T1 P3380 【模板】二逼平衡树（树套树）

【模板】二逼平衡树（树套树）
题目描述
您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：

• 查询k在区间内的排名
• 查询区间内排名为$k$的值
• 修改某一位值上的数值
• 查询k在区间内的前驱(前驱定义为严格小于$x$，且最大的数，若不存在输出$-2147483647$)
• 查询k在区间内的后继(后继定义为严格大于$x$，且最小的数，若不存在输出$2147483647$)

输入格式
第一行两个数 $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$的后继

输出格式
对于操作$1,2,4,5$各输出一行，表示查询结果

输入输出样例
输入
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
输出
2
4
3
4
9
说明/提示
时空限制：2s，128M
$n,m\le 5\cdot {10}^4$
保证有序序列所有值在任何时刻满足 $[0,{10}^8]$
（特别提醒：此数据不保证操作$4、5$一定存在，故请务必考虑不存在的情况）

思路：
线段树套平衡树
对于每个线段树区间暴力建平衡树

• 对于操作一：在每个线段树区间中找比$k$小的数的个数，累加（最后排名要加一）（时间复杂度：$O(lo{g}^{2}n)$）
• 对于操作二：二分答案，用操作一验证（时间复杂度：$O(lo{g}^{3}n)$）
• 对于操作三：将每个线段树区间中的平衡树修改（时间复杂度：$O(lo{g}^{2}n)$）
• 对于操作四：在每个线段树区间中查前驱，取最小（时间复杂度：$O(lo{g}^{2}n)$）
• 对于操作五：在每个线段树区间中查后驱，取最大（时间复杂度：$O(lo{g}^{2}n)$）

时间复杂度：$O(nlo{g}^{3}n)$

代码：

#include<bits/stdc++.h>
using namespace std;
#define in Read()
#define lson p<<1
#define rson p<<1|1

inline char ch(){
	static char buf[1<<21],*p1=buf,*p2=buf;
	return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;
}

inline int in{
	int s=0,f=1;char x;
	for(x=ch();x<'0'||x>'9';x=ch())	if(x=='-')	f=-1;
	for( ;x>='0'&&x<='9';x=ch())	s=(s<<1)+(s<<3)+(x&15);
	return f==1?s:-s;
}

const int A=1e5+5;
int n,m;
int v[A],maxx;
struct Tree{
	int l,r,root;
}tree[4*A];
struct Treap{
	int rnk,size,val,lch,rch;
}rt[18*A];
int tot;

inline void pushup(int x){
	rt[x].size=rt[rt[x].lch].size+rt[rt[x].rch].size+1;
	return;
}

inline int merge(int x,int y){
	if(!x||!y)	return x+y;
	if(rt[x].rnk>rt[y].rnk){
		rt[x].rch=merge(rt[x].rch,y);
		pushup(x);
		return x;
	}
	else{
		rt[y].lch=merge(x,rt[y].lch);
		pushup(y);
		return y;
	}
}

inline void split_val(int now,int val,int &x,int &y){
	if(!now){
		x=y=0;
		return;
	}
	if(rt[now].val>=val){
		y=now;
		split_val(rt[now].lch,val,x,rt[now].lch);
	}
	else{
		x=now;
		split_val(rt[now].rch,val,rt[now].rch,y);
	}
	pushup(now);
	return;
}

inline void split_num(int now,int num,int &x,int &y){
	if(!now){
		x=y=0;
		return;
	}
	if(rt[rt[now].lch].size>=num){
		y=now;
		split_num(rt[now].lch,num,x,rt[now].lch);
	}
	else{
		x=now;
		split_num(rt[now].rch,num-rt[rt[now].lch].size-1,rt[now].rch,y);
	}
	pushup(now);
	return;
}

inline int New(int x){
	rt[++tot].rnk=rand();
	rt[tot].size=1;
	rt[tot].val=x;
	return tot;
}

inline void build(int p,int l,int r){
	tree[p].l=l,tree[p].r=r;
	for(int i=l;i<=r;i++){
		int x,y;
		split_val(tree[p].root,v[i],x,y);
		tree[p].root=merge(merge(x,New(v[i])),y);
	}
	if(l==r)	return;
	int mid=(l+r)>>1;
	build(lson,l,mid),build(rson,mid+1,r);
	return;
}

inline int qurey_num(int p,int l,int r,int val){
	if(tree[p].l>=l&&tree[p].r<=r){
		int x,y;
		split_val(tree[p].root,val,x,y);
		int ans=rt[x].size;
		tree[p].root=merge(x,y);
		return ans;
	}
	int ans=0;
	int mid=(tree[p].l+tree[p].r)>>1;
	if(l<=mid)	ans+=qurey_num(lson,l,r,val);
	if(r>=mid+1)	ans+=qurey_num(rson,l,r,val);
	return ans;
}

inline void change(int p,int w,int val){
	int x,y,z;
	split_val(tree[p].root,v[w],x,y);
	split_num(y,1,y,z);
	tree[p].root=merge(x,z);
	split_val(tree[p].root,val,x,y);
	tree[p].root=merge(merge(x,New(val)),y);
	if(tree[p].l==tree[p].r){
		v[w]=val;
		return;
	}
	int mid=(tree[p].l+tree[p].r)>>1;
	if(w<=mid)	change(lson,w,val);
	else	change(rson,w,val);
	return;
}

int res;

inline void qurey_min(int p,int l,int r,int val){
	if(tree[p].l>=l&&tree[p].r<=r){
		int x,y,z;
		split_val(tree[p].root,val,x,y);
		if(rt[x].size){
			split_num(x,rt[x].size-1,x,z);
			res=max(res,rt[z].val);
			x=merge(x,z);
		}
		tree[p].root=merge(x,y);
		return;
	}
	int mid=(tree[p].l+tree[p].r)>>1;
	if(l<=mid)	qurey_min(lson,l,r,val);
	if(r>=mid+1)	qurey_min(rson,l,r,val);
	return;
}

inline void qurey_max(int p,int l,int r,int val){
	if(tree[p].l>=l&&tree[p].r<=r){
		int x,y,z;
		split_val(tree[p].root,val+1,x,y);
		if(rt[y].size){
			split_num(y,1,y,z);
			res=min(res,rt[y].val);
			y=merge(y,z);
		}
		tree[p].root=merge(x,y);
		return;
	}
	int mid=(tree[p].l+tree[p].r)>>1;
	if(l<=mid)	qurey_max(lson,l,r,val);
	if(r>=mid+1)	qurey_max(rson,l,r,val);
	return;
}

signed main(){ 
	srand(time(0));
	n=in,m=in;
	for(int i=1;i<=n;i++){
		v[i]=in;
		maxx=max(maxx,v[i]);
	}
	build(1,1,n);
	for(int i=1;i<=m;i++){
		int opt=in;
		if(opt==1){
			int l=in,r=in,k=in;
			printf("%d\n",qurey_num(1,l,r,k)+1);
		}
		else if(opt==2){
			int l=in,r=in,k=in;
			int L=0,R=maxx,ans=0;
			while(L<=R){
				int mid=(L+R)>>1;
				if(qurey_num(1,l,r,mid)+1>k)	R=mid-1;
				else	ans=mid,L=mid+1;
			}
			printf("%d\n",ans);
		}
		else if(opt==3){
			int pos=in,k=in;
			change(1,pos,k);
		}
		else if(opt==4){
			int l=in,r=in,k=in;
			res=-2147483647;
			qurey_min(1,l,r,k);
			printf("%d\n",res);
		}
		else if(opt==5){
			int l=in,r=in,k=in;
			res=2147483647;
			qurey_max(1,l,r,k);
			printf("%d\n",res);
		}
	}
	return 0;
}