BZOJ 3489: A simple rmq problem 树套树

3489: A simple rmq problem

Time Limit: 40 Sec  Memory Limit: 600 MB
Submit: 2061  Solved: 701
[Submit][Status][Discuss]

Description

因为是OJ上的题，就简单点好了。给出一个长度为n的序列，给出M个询问：在[l,r]之间找到一个在这个区间里只出现过一次的数，并且要求找的这个数尽可能大。如果找不到这样的数，则直接输出0。我会采取一些措施强制在线。

Input

第一行为两个整数N,M。M是询问数，N是序列的长度（N<=100000，M<=200000)

第二行为N个整数，描述这个序列{ai}，其中所有1<=ai<=N

再下面M行，每行两个整数x，y，

询问区间[l,r]由下列规则产生（OIER都知道是怎样的吧>_<)：

l=min(（x+lastans)mod n+1,(y+lastans）mod n+1);

r=max(（x+lastans)mod n+1,(y+lastans）mod n+1);

Lastans表示上一个询问的答案，一开始lastans为0

Output

一共M行，每行给出每个询问的答案。

Sample Input

10 10
6 4 9 10 9 10 9 4 10 4
3 8
10 1
3 4
9 4
8 1
7 8
2 9
1 1
7 3
9 9

Sample Output

4
10
10
0
0
10
0
4
0
4

HINT

注意出题人为了方便，input的第二行最后多了个空格。

2015.6.24新加数据一组，2016.7.9放至40S,600M,但未重测

先来一波可怜被卡版

bzoj 3489: A simple rmq problem k-d树思想大暴力

不过 这种东西很适合OI赛制啊。。。

#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;

typedef double db;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=100100,inf=0X3f3f3f3f;

int a[N];

struct seg_tree
{
	int ls,rs,mn,mx;
	seg_tree(){mn=inf;mx=-inf;}
}tr[N*20];
int root[N];
int sz;

void modify(int &k,int x,int l,int r,int pos,int val1,int val2)
{
	k=++sz;
	tr[k].ls=tr[x].ls;
	tr[k].rs=tr[x].rs;
	if(l==r)
	{
		tr[k].mn=val1;tr[k].mx=val2;
		return ;
	}
	int mid=(l+r)>>1;
	pos<=mid?modify(tr[k].ls,tr[x].ls,l,mid,pos,val1,val2):modify(tr[k].rs,tr[k].rs,mid+1,r,pos,val1,val2);
	tr[k].mn=min(tr[tr[k].ls].mn,tr[tr[k].rs].mn);
	tr[k].mx=max(tr[tr[k].ls].mx,tr[tr[k].rs].mx);
}

int query(int k,int l,int r,int pos)
{
	if(l==r)
		return (pos<=tr[k].mx&&pos>=tr[k].mn)?l:0;
	int res=0;
	int mid=(l+r)>>1;
	if(tr[tr[k].rs].mn<=pos&&tr[tr[k].rs].mx>=pos)
	{
		res=query(tr[k].rs,mid+1,r,pos);
		if(res)return res;
	}
	return query(tr[k].ls,l,mid,pos);
}

int last[N],pre[N];

int main()
{
	int n=read();
	register int Q=read(),i,l,r;
	for(i=1;i<=n;++i)
	{
		a[i]=read();
		pre[i]=last[a[i]];
		last[a[i]]=i;
	}
	for(i=1;i<=n;++i)
		modify(root[i],root[i-1],0,n,a[i],pre[i]+1,i);
	int ans=0;
	while(Q--)
	{
		l=(read()+ans)%n+1;r=(read()+ans)%n+1;
		if(l>r)swap(l,r);
		ans=query(root[r],0,n,l);
		print(ans);putchar('\n');
	}
}

被卡之后心灰意冷

再翻题解 看到 KD-tree 眼前一亮 思想江化了啊。

但是 写这个是为了练习树套树啊啊啊啊

于是就%了一发主席树套主席树

bzoj3489 A simple rmq problem

外层是区间线段树

内层还是区间线段树

#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;

typedef double db;
	
inline int read()
{
    int x=0,c=0;
    while(c<'0'||c>'9')c=getchar();
	while(c>='0'&&c<='9')x=x*10+c-'0',c=getchar();
    return x;
}
void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=100100,inf=0X3f3f3f3f;

struct node
{
	int val,pre,nt,pos;
	friend bool operator <(const node &x,const node &y)
	{return x.pre<y.pre;}
}a[N];

struct president_tree{int ls,rs,root;}tr[N<<6];
int root[N];
int mx[N*450],ls[N*450],rs[N*450];
int sz,tot;

int n,ans;

void modify(int &k,int x,int l,int r,int pos,int val)
{
	k=++tot;
	mx[k]=max(mx[x],val);
	if(l==r)return ;
	ls[k]=ls[x];rs[k]=rs[x];
	int mid=(l+r)>>1;
	pos<=mid?modify(ls[k],ls[x],l,mid,pos,val):modify(rs[k],rs[x],mid+1,r,pos,val);
}

void modify(int &k,int x,int l,int r,int aim,int pos,int val)
{
	k=++sz;
	modify(tr[k].root,tr[x].root,1,n,pos,val);
	if(l==r)return ;
	int mid=(l+r)>>1;
	tr[k].ls=tr[x].ls;tr[k].rs=tr[x].rs;
	aim<=mid?modify(tr[k].ls,tr[x].ls,l,mid,aim,pos,val):modify(tr[k].rs,tr[x].rs,mid+1,r,aim,pos,val);
}

void query(int k,int l,int r,int y)
{
	if(y<=l)
	{
		ans=max(ans,mx[k]);
		return ;
	}
	int mid=(l+r)>>1;
	if(y<=mid)query(ls[k],l,mid,y);
	query(rs[k],mid+1,r,y);
}

void query(int k,int l,int r,int x,int y)
{
	if(l>=x&&r<=y)
	{
		query(tr[k].root,1,n,y);
		return ;
	}
	int mid=(l+r)>>1;
	if(x<=mid)query(tr[k].ls,l,mid,x,y);
	if(y>mid)query(tr[k].rs,mid+1,r,x,y);
}

int last[N];

int main()
{
	n=read();int Q=read();
	register int i,x,y;
	for(i=1;i<=n;++i)
	{
		x=read();
		a[i].pos=i;
		a[i].val=x;
		a[i].pre=last[x]+1;
		last[x]=i;
	}
	fill(last,last+n+1,n+1);
	for(i=n;i;i--)
	{
		a[i].nt=last[a[i].val]-1;
		last[a[i].val]=i;
	}
	sort(a+1,a+1+n);
	register int now=1;
	for(i=1;i<=n;++i)
	{
		root[i]=root[i-1];
		while(now<=n&&a[now].pre<=i)
		{
			modify(root[i],root[i],1,n,a[now].pos,a[now].nt,a[now].val);
			now++;
		}
	}
	while(Q--)
	{
		x=(read()+ans)%n+1;y=(read()+ans)%n+1;
		if(x>y)swap(x,y);
		ans=0;
		query(root[x],1,n,x,y);
		print(ans);puts("");
	}
	return 0;
}
/*
10 10
6 4 9 10 9 10 9 4 10 4 
3 8
10 1
3 4
9 4
8 1
7 8
2 9
1 1
7 3
9 9

4
10
10
0
0
10
0
4
0
4
*/