BZOJ3489 A simple rmq problem

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

还是吐槽一下BZOJ的土豆，什么数组开小了显示WA，数组开大一点就CE，这可真是友好，请问RE呢？MLE呢？？？？？？？？？

然后讲讲这题思路

一开始看到以为是树套树套树

蒙圈了

想了⑩分钟无果然后就去看题解

结果发现可以用排序的方法把三维降成两维

只不过嘛。需要可持久化

不过我们不虚

可持久化树套树不就是在可持久化线段树上多加一句插入吗

首先我们考虑一个数在区间内出现一次的充要条件是什么

1.l<=posi<=r" role="presentation">1.l<=posi<=r1.l<=posi<=r

2.l>prei" role="presentation">2.l>prei2.l>prei

3.r<nxti" role="presentation">3.r<nxti3.r<nxti

其中pos表示位置，pre和nxt分别表示上一个和下一个这个数出现的位置

很妙啊

我们考虑以pre为键值排序

然后我们发现我们查询的区间变成了一个前缀

所以就将pre可持久化一下

然后我们又发现nxt也是我们的限制条件

所以我们在外层的树上以nxt为下标，所以查询就变成了在线段树上查询后缀

但是还有pos的限制怎么办？

所以就把内层树搞成原序列的位置就好了

然后查询的时候非常套路地二分一下pre的位置，剩下的该怎么查怎么查

#include<bits/stdc++.h>

using namespace std;

inline int read(){

    int ans=0,w=1;char c=getchar();

    while(!isdigit(c)&&c!='-')c=getchar();

    if(c=='-')w=-1,c=getchar();

    while(isdigit(c))ans=(ans<<1)+(ans<<3)+c-'0',c=getchar();

    return ans*w;

}

#define N 100010

int n,m,lastans=0;

struct Node{int val,pos,pre,nxt;}p[N];

bool cmp(Node a,Node b){return a.pre<b.pre;}

//inside 原序列顺序

int ld[N*350],rd[N*350],maxv[N*350];

int cnt=0;

void insert(int &t,int last,int l,int r,int pos,int vl){

    t=++cnt;

    maxv[t]=max(vl,maxv[last]);

    if(l==r)return;

    ld[t]=ld[last];

    rd[t]=rd[last];

    int mid=(l+r)>>1;

    if(pos<=mid)insert(ld[t],ld[last],l,mid,pos,vl);

    else insert(rd[t],rd[last],mid+1,r,pos,vl);

}

int query(int t,int l,int r,int L,int R){

    if(!t)return 0;

    if(L<=l&&r<=R)return maxv[t];

    int mid=(l+r)>>1;

    if(R<=mid)return query(ld[t],l,mid,L,R);

    if(L>mid)return query(rd[t],mid+1,r,L,R);

    return max(query(ld[t],l,mid,L,R),query(rd[t],mid+1,r,L,R));

}

//outside nxt顺序

int rt[N*20],lc[N*20],rc[N*20],tot=0;

void insert(int &t,int last,int l,int r,int key,int pos,int vl){

    t=++tot;

    insert(rt[t],rt[last],1,n,pos,vl);

    if(l==r)return;

    lc[t]=lc[last];

    rc[t]=rc[last];

    int mid=(l+r)>>1;

    if(key<=mid)insert(lc[t],lc[last],l,mid,key,pos,vl);

    else insert(rc[t],rc[last],mid+1,r,key,pos,vl);

}

int query(int t,int l,int r,int L,int R,int ql,int qr){

    if(!t)return 0;

    if(L<=l&&r<=R)return query(rt[t],1,n,ql,qr);

    int mid=(l+r)>>1;

    if(R<=mid)return query(lc[t],l,mid,L,R,ql,qr);

    if(L>mid)return query(rc[t],mid+1,r,L,R,ql,qr);

    return max(query(lc[t],l,mid,L,R,ql,qr),query(rc[t],mid+1,r,L,R,ql,qr));

}

int outrt[N];

int pre[N],nxt[N];

int main(){

    scanf("%d%d",&n,&m);

    for(int i=1;i<=n;i++)p[i].pos=i,scanf("%d",&p[i].val);

    for(int i=1;i<=n;i++)pre[i]=0,nxt[i]=n+1;

    for(int i=1;i<=n;i++)p[i].pre=pre[p[i].val],pre[p[i].val]=i;

    for(int i=n;i>=1;i--)p[i].nxt=nxt[p[i].val],nxt[p[i].val]=i;

    //for(int i=1;i<=1000;i++)cout<<i<<" "<<p[i].pre<<" "<<p[i].nxt<<endl;

    sort(p+1,p+n+1,cmp);

    for(int i=1;i<=n;i++)//持久化pre的顺序

        insert(outrt[i],outrt[i-1],1,n+1,p[i].nxt,p[i].pos,p[i].val);

    for(int i=1;i<=m;i++){

        int l,r;

        scanf("%d%d",&l,&r);

        l=(l+lastans)%n+1;

        r=(r+lastans)%n+1;

        if(l>r)swap(l,r);

        int ql=1,qr=n,tmp=0;

        while(ql<=qr){

            int mid=(ql+qr)>>1;

            if(p[mid].pre<l)ql=mid+1,tmp=mid;

            else qr=mid-1;

        }

        printf("%d\n",lastans=query(outrt[tmp],1,n+1,r+1,n+1,l,r));

    }

    return 0;

}

可持久化