BZOJ 2653: middle 二分 主席树

2653: middle

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 2169  Solved: 1203
[Submit][Status][Discuss]

Description

一个长度为n的序列a，设其排过序之后为b，其中位数定义为b[n/2]，其中a,b从0开始标号,除法取下整。给你一个长度为n的序列s。回答Q个这样的询问：s的左端点在[a,b]之间,右端点在[c,d]之间的子序列中，最大的中位数。其中a<b<c<d。位置也从0开始标号。我会使用一些方式强制你在线。

Input

第一行序列长度n。接下来n行按顺序给出a中的数。

接下来一行Q。然后Q行每行a,b,c,d，我们令上个询问的答案是

x(如果这是第一个询问则x=0)。

令数组q={(a+x)%n,(b+x)%n,(c+x)%n,(d+x)%n}。

将q从小到大排序之后，令真正的

要询问的a=q[0],b=q[1],c=q[2],d=q[3]。　　

输入保证满足条件。

第一行所谓“排过序”指的是从大到小排序！

Output

Q行依次给出询问的答案。

Sample Input

5
170337785
271451044
22430280
969056313
206452321
3
3 1 0 2
2 3 1 4
3 1 4 0

271451044
271451044
969056313

Sample Output

HINT

0:n,Q<=100

1,...,5:n<=2000

0,...,19:n<=20000,Q<=25000

这真是一道妙题

首先要涉及到一个套路问题 //BJ过于脑残忘掉了 所以没做出来

对于选定的x 把<x的数看成-1 >=x的看成1

这时只要存在一个子序列的和>=0 即可说明中位数>=x

这样就可以二分啦

现在怎么解决每次的check成为了问题

考虑要二分权值 所以权值应该在最外层

之后是区间的选取 那么这段区间一定是 [b,c]+[a,b)右侧最大+(c,d]左侧最大 从而获得最优解

这个操作考虑用线段树解决

现在每次的权值改变无疑是个大问题

那么考虑每次权值由小到大改变 与上一个权值的线段树之间的差别其实只有这一个权值由1变成-1

这样就可以用主席树了

对于每个权值维护区间线段树即可

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<set>
#include<map>
using namespace std;

inline int read()
{
	int x=0,f=1;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 void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=20100;

int n;

struct point
{
	int val,pos;
	
	friend bool operator <(const point &x,const point &y)
	{return x.val<y.val;}
}p[N];

struct president_tree{int ls,rs,sum,mxl,mxr;}tr[N<<6];
int root[N],sz;

inline void pushup(int k)
{
	int ls(tr[k].ls),rs(tr[k].rs);
	tr[k].sum=tr[ls].sum+tr[rs].sum;
	tr[k].mxl=max(tr[ls].mxl,tr[ls].sum+tr[rs].mxl);
	tr[k].mxr=max(tr[rs].mxr,tr[rs].sum+tr[ls].mxr);
}

void build(int &k,int l,int r)
{
	k=++sz;
	if(l==r)
	{
		tr[k].sum=tr[k].mxl=tr[k].mxr=1;
		return ;
	}
	int mid=(l+r)>>1;
	build(tr[k].ls,l,mid);build(tr[k].rs,mid+1,r);
	pushup(k);
}

void modify(int &k,int pre,int l,int r,int x)
{
	k=++sz;
	if(l==r)
	{
		tr[k].sum=tr[k].mxl=tr[k].mxr=-1;
		return ;
	}
	int mid=(l+r)>>1;
	tr[k].ls=tr[pre].ls;tr[k].rs=tr[pre].rs;
	x<=mid ? modify(tr[k].ls,tr[pre].ls,l,mid,x) : modify(tr[k].rs,tr[pre].rs,mid+1,r,x);
	pushup(k);
}

int query_sum(int k,int l,int r,int x,int y)
{
	if(x>y) return 0;
	if(l>=x && r<=y) return tr[k].sum;
	int mid((l+r)>>1),s(0),t(0);
	if(x<=mid) s=query_sum(tr[k].ls,l,mid,x,y);
	if(y>mid) t=query_sum(tr[k].rs,mid+1,r,x,y);
	return s+t;
}

int query_mxl(int k,int l,int r,int x,int y)
{
	if(l>=x && r<=y) return tr[k].mxl;
	int mid((l+r)>>1);
	if(x>mid) return query_mxl(tr[k].rs,mid+1,r,x,y);
	if(y<=mid) return query_mxl(tr[k].ls,l,mid,x,y);
	return max(query_mxl(tr[k].ls,l,mid,x,y),query_sum(tr[k].ls,l,mid,x,y)+query_mxl(tr[k].rs,mid+1,r,x,y));
}

int query_mxr(int k,int l,int r,int x,int y)
{
	if(l>=x && r<=y) return tr[k].mxr;
	int mid((l+r)>>1);
	if(x>mid) return query_mxr(tr[k].rs,mid+1,r,x,y);
	if(y<=mid) return query_mxr(tr[k].ls,l,mid,x,y);
	return max(query_mxr(tr[k].rs,mid+1,r,x,y),query_sum(tr[k].rs,mid+1,r,x,y)+query_mxr(tr[k].ls,l,mid,x,y));
}

int opt[5];

bool check(int x)
{
	return
		query_sum(root[x],1,n,opt[1]+1,opt[2]-1)+
		query_mxl(root[x],1,n,opt[2],opt[3])+
		query_mxr(root[x],1,n,opt[0],opt[1])
		>=0;
}

int main()
{
	n=read();
	register int i,l,r,mid,Q,ans(0);
	for(i=1;i<=n;++i)
		p[i].val=read(),p[i].pos=i;
	sort(p+1,p+1+n);
	build(root[1],1,n);
	for(i=2;i<=n;++i)
		modify(root[i],root[i-1],1,n,p[i-1].pos);
	Q=read();
	while(Q--)
	{
		opt[0]=(read()+ans)%n+1,opt[1]=(read()+ans)%n+1,
		opt[2]=(read()+ans)%n+1,opt[3]=(read()+ans)%n+1;
		sort(opt,opt+4);
		l=1,r=n;
		while(l<=r)
		{
			mid=(l+r)>>1;
			check(mid) ? l=mid+1 : r=mid-1;
		}
		print(ans=p[l-1].val);puts("");
	}
	return 0;
}