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
;

struct seg_tree
{
int ls,rs,mn,mx;
seg_tree(){mn=inf;mx=-inf;}
}tr[N*20];
int root
;
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
,pre
;

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
;

struct president_tree{int ls,rs,root;}tr[N<<6];
int root
;
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
;

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
*/