【学校OJ】 avl平衡树+线段树 二逼平衡树

题目描述

你需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：

1.查询k在区间内的排名, 一个数的rank是比它小的数的个数+1

2.查询区间内排名为k的值

3.修改某一位置上的数值

4.查询k在区间内的前驱(前驱定义为小于x，且最大的数)

5.查询k在区间内的后继(后继定义为大于x，且最小的数)

输入

第一行两个数 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(1<=pos<=n)位置的数修改为k

若opt=4 则为操作4，之后有三个数l,r,k 表示查询区间[l,r]内k的前驱

若opt=5 则为操作5，之后有三个数l,r,k 表示查询区间[l,r]内k的后继

输出

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

样例输入

Copy (如果复制到控制台无换行，可以先粘贴到文本编辑器，再复制)

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

提示

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

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

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

    重温最美平衡树……

    写这一道让人倍感再也不会再爱了的题着实让我的心灵收到了一万点创伤……

    好吧切入正题……题目中需要查询区间，我们不约而同地想到了我们可爱的线段树，但又因为需要查询排名正是平衡树的拿手好戏，再看看时间限制，我们很直接地想到了——线段树套平衡树！只要在每一颗线段树上都建立一颗平衡树即可，虽然树套树感觉上空间开不下，但其实不是的。线段树最多有4*N的空间，也就有4*N个根，如果开成200000*50000明显不行，但我们可以公用一块连续区间，因为线段树每一层会有N个节点，只需要算有多少层即可，计算出log(50000)≈15，则把数组开成15*50000，保险点开成四倍，也就是3000000个，加上线段树的200000就是3200000，并不会爆掉。

    然后1、3、4、5就全都可以很轻松地解决了，至于2却不可以像往常那样做（因为在不同的平衡树中查询很困难），所以我们采用二分答案，枚举这一个数，用1的方法去验证是否正确，找到最靠右的满足条件的数，然后就把它输出出来即可。

    虽说思路并不难，但是写代码的过程真的好伤啊……写了两个小时才写出来……

/*
"Who are you?"

"I was a Segment Tree.
But now I am a Balanced Tree."

"I can help you.
I will help you to be...
a Segment Balanced Tree."
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#include<climits>
using namespace std;
#define N 200005 //线段树节点数
#define M 3000005 //平衡树节点数
#define inf 2147483647 //正无穷
int num[N];//数组（记录序列变化情况）
int l[N],r[N];//线段树
int root[N],cnt;//每棵线段树中的平衡树根,平衡树节点数
int data[M],h[M],ls[M],rs[M],size[M];//数据域,平衡因子,左右儿子,节点数
void make(int x,int y,int q)//建线段树
{
	l[q]=x;r[q]=y;
	root[q]=0;
	if(x<y)
	{
		int mid=(x+y)>>1;
		make(x,mid,q<<1);
		make(mid+1,y,q<<1|1);
	}
}
int zig(int q)//右旋
{
	int p=ls[q];
	ls[q]=rs[p];
	rs[p]=q;
	h[p]=max(h[ls[p]],h[rs[p]])+1;
	size[p]=size[ls[p]]+size[rs[p]]+1;
	h[q]=max(h[ls[q]],h[rs[q]])+1;
	size[q]=size[ls[q]]+size[rs[q]]+1;
	return p;
}
int zag(int q)//左旋
{
	int p=rs[q];
	rs[q]=ls[p];
	ls[p]=q;
	h[p]=max(h[ls[p]],h[rs[p]])+1;
	size[p]=size[ls[p]]+size[rs[p]]+1;
	h[q]=max(h[ls[q]],h[rs[q]])+1;
	size[q]=size[ls[q]]+size[rs[q]]+1;
	return p;
}
int zigzag(int q)//右左旋
{
	rs[q]=zig(rs[q]);
	return zag(q);
}
int zagzig(int q)//左右旋
{
	ls[q]=zag(ls[q]);
	return zig(q);
}
void move(int &q)//调整以q为根的平衡树
{
	if(h[ls[q]]-h[rs[q]]==2)
	{
		if(h[ls[ls[q]]]>h[rs[ls[q]]])
			q=zig(q);
		else
			q=zagzig(q);
	}
	if(h[ls[q]]-h[rs[q]]==-2)
	{
		if(h[rs[rs[q]]]>h[ls[rs[q]]])
			q=zag(q);
		else
			q=zigzag(q);
	}
	h[q]=max(h[ls[q]],h[rs[q]])+1;
	size[q]=size[ls[q]]+size[rs[q]]+1;
}
void insert_b(int a,int &q)//在以q为根的平衡树上插入一个a
{
	if(!q)
	{
		q=++cnt;
		data[q]=a;
		h[q]=1;
		size[q]=1;
		return;
	}
	if(a<data[q])
		insert_b(a,ls[q]);
	else
		insert_b(a,rs[q]);
	move(q);
}
void insert_s(int k,int a,int q)//在线段树位置k插入一个a
{
	if(l[q]<=k&&r[q]>=k)
		insert_b(a,root[q]);
	if(l[q]<r[q])
	{
		int mid=(l[q]+r[q])>>1;
		if(k<=mid)
			insert_s(k,a,q<<1);
		else
			insert_s(k,a,q<<1|1);
	}
}
void erase_b(int a,int &q)//在以q为根的平衡树上删除一个a
{
	if(!q)
		return;
	if(data[q]==a)
	{
		if(!ls[q]||!rs[q])
		{
			q=ls[q]+rs[q];
			if(q==0)
				return;
		}
		else
		{
			int p=ls[q];
			while(rs[p])
				p=rs[p];
			data[q]=data[p];
			erase_b(data[p],ls[q]);
		}
	}
	else
	{
		if(a<data[q])
			erase_b(a,ls[q]);
		else
			erase_b(a,rs[q]);
	}
	move(q);
}
void erase_s(int k,int a,int q)//在线段树位置k删除一个a
{
	if(l[q]<=k&&r[q]>=k)
		erase_b(a,root[q]);
	if(l[q]>k||r[q]<k)
		return;
	if(l[q]<r[q])
	{
		int mid=(l[q]+r[q])>>1;
		if(k<=mid)
			erase_s(k,a,q<<1);
		else
			erase_s(k,a,q<<1|1);
	}
}
int front_b(int a,int q)//在以q为根的平衡树上查询a的前驱
{
	if(!q)
		return -inf;
	if(data[q]>=a)
		return front_b(a,ls[q]);
	else
		return max(front_b(a,rs[q]),data[q]);
}
int front_s(int x,int y,int a,int q)//在线段树区间[x,y]查询a的前驱
{
	if(x<=l[q]&&y>=r[q])
		return front_b(a,root[q]);
	if(l[q]>y||r[q]<x)
		return -inf;
	return max(front_s(x,y,a,q<<1),front_s(x,y,a,q<<1|1));
}
int back_b(int a,int q)//在以q为根的平衡树上查询a的后继
{
	if(!q)
		return inf;
	if(data[q]<=a)
		return back_b(a,rs[q]);
	else
		return min(back_b(a,ls[q]),data[q]);
}
int back_s(int x,int y,int a,int q)//在线段树区间[x,y]查询a的后继
{
	if(x<=l[q]&&y>=r[q])
		return back_b(a,root[q]);
	if(l[q]>y||r[q]<x)
		return inf;
	return min(back_s(x,y,a,q<<1),back_s(x,y,a,q<<1|1));
}
int find_b(int a,int q)//在以q为根的平衡树上查询小于a的数个数
{
	if(!q)
		return 0;
	if(data[q]<a)
		return size[ls[q]]+1+find_b(a,rs[q]);
	else
		return find_b(a,ls[q]);
}
int find_s(int x,int y,int a,int q)//在线段树区间[x,y]查询小于a的数个数
{
	if(x<=l[q]&&y>=r[q])
		return find_b(a,root[q]);
	if(l[q]>y||r[q]<x)
		return 0;
	return find_s(x,y,a,q<<1)+find_s(x,y,a,q<<1|1);
}
int ask_s(int x,int y,int k)//在线段树区间[x,y]查询排名为k的数
{
	int l=0,r=inf,tot,ans=0;
	while(l<=r)
	{
		int mid=(l+r)>>1;
		tot=find_s(x,y,mid,1)+1;
		if(tot<=k)
		{
			l=mid+1;
			ans=mid;
		}
		else
			r=mid-1;
	}
	return ans;
}
int n,m;
int main()
{
	scanf("%d%d",&n,&m);
	make(1,n,1);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&num[i]);
		insert_s(i,num[i],1);
	}
	for(int i=1;i<=m;i++)
	{
		int opt,k,x,y,pos;
		scanf("%d",&opt);
		if(opt==1)
		{
			scanf("%d%d%d",&x,&y,&k);
			printf("%d\n",find_s(x,y,k,1)+1);
		}
		if(opt==2)
		{
			scanf("%d%d%d",&x,&y,&k);
			printf("%d\n",ask_s(x,y,k));
		}
		if(opt==3)
		{
			scanf("%d%d",&pos,&k);
			erase_s(pos,num[pos],1);
			insert_s(pos,k,1);
			num[pos]=k;
		}
		if(opt==4)
		{
			scanf("%d%d%d",&x,&y,&k);
			printf("%d\n",front_s(x,y,k,1));
		}
		if(opt==5)
		{
			scanf("%d%d%d",&x,&y,&k);
			printf("%d\n",back_s(x,y,k,1));
		}
	}
}