bzoj 3489: A simple rmq problem 可持久化线段树套可持久化线段树

题意

给出n个数，每个数为[1,n]，有m个询问，每次询问[l,r]内最大的只出现过一次的数。强制在线。
n<=100000,m<=200000

分析

一开始还以为是分块，但想了想发现不可做，然后想了一下主席树什么的也还是不会做，就只好去看题解了。然后发现有好多神奇的做法，像KDtree，树套树，树套堆等，但我到现在还不会怎么用树套堆来做。

先求出每一个位置的next和last分别表示前面第一个和它的数一样的位置和后面第一个和它的数一样的位置。那么问题就转换成了在[l,r]内求一个x，满足last[x] < l且next[x]>r且l<=x<=r且a[x]最大。
我们可以把每个位置按照last排个序，然后从头开始建可持久化线段树，维护的是next值，然后线段树的每个节点再建一棵可持久化线段树，维护的是区间最大值，那么查询就按照普通的树套树查询即可。

在bzoj上面跑了22s+，已经是倒数第三了，好不爽啊~~

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define N 100005
using namespace std;

struct data
{
    int val,pos,next,last;

    bool operator < (const data &a) const
    {
        return last<a.last;
    }
}a[N];

int n,m,t[N];

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

struct Segtree_Out
{

    int root[N*25],tot;
    struct tree{int mx,l,r;}t[N*450];

    void ins(int &d,int p,int l,int r,int pos,int val)
    {
        d=++tot;
        t[d].mx=max(t[d].mx,max(val,t[p].mx));
        t[d].l=t[p].l,t[d].r=t[p].r;
        if (l==r) return;
        int mid=(l+r)/2;
        if (pos<=mid) ins(t[d].l,t[p].l,l,mid,pos,val);
        else ins(t[d].r,t[p].r,mid+1,r,pos,val);
    }

    int query(int d,int l,int r,int x,int y)
    {
        if (l==x&&r==y||!d) return t[d].mx;
        int mid=(l+r)/2;
        if (y<=mid) return query(t[d].l,l,mid,x,y);
        else if (x>mid) return query(t[d].r,mid+1,r,x,y);
        else return max(query(t[d].l,l,mid,x,mid),query(t[d].r,mid+1,r,mid+1,y));
    }

}tree2;

struct Segtree_In
{

    int root[N],tot;
    struct tree{int l,r;}t[N*25];

    void ins(int &d,int p,int l,int r,int x)
    {
        d=++tot;
        t[d].l=t[p].l;t[d].r=t[p].r;
        tree2.ins(tree2.root[d],tree2.root[p],1,n,a[x].pos,a[x].val);
        if (l==r) return;
        int mid=(l+r)/2;
        if (a[x].next<=mid) ins(t[d].l,t[p].l,l,mid,x);
        else ins(t[d].r,t[p].r,mid+1,r,x);
    }

    int query(int d,int l,int r,int x,int y)
    {
        if (!d) return 0;
        if (l>y) return tree2.query(tree2.root[d],1,n,x,y);
        int mid=(l+r)/2;
        if (mid<=y) return query(t[d].r,mid+1,r,x,y);
        else return max(query(t[d].l,l,mid,x,y),query(t[d].r,mid+1,r,x,y));
    }

}tree1;

int ef(int x)
{
    int l=1,r=n;
    while (l<=r)
    {
        int mid=(l+r)/2;
        if (a[mid].last<x) l=mid+1;
        else r=mid-1;
    }
    return l-1;
}

int main()
{
    n=read();m=read();
    for (int i=1;i<=n;i++)
    {
        a[i].val=read();
        a[i].pos=i;
    }
    for (int i=1;i<=n;i++)
    {
        if (t[a[i].val]) a[i].last=t[a[i].val];
        t[a[i].val]=i;
    }
    memset(t,0,sizeof(t));
    for (int i=n;i>=1;i--)
    {
        if (t[a[i].val]) a[i].next=t[a[i].val];
        else a[i].next=n+1;
        t[a[i].val]=i;
    }
    sort(a+1,a+n+1);
    for (int i=1;i<=n;i++)
        tree1.ins(tree1.root[i],tree1.root[i-1],1,n+1,i);
    int lastans=0;
    for (int i=1;i<=m;i++)
    {
        int l=read(),r=read();
        l=(l+lastans)%n+1;r=(r+lastans)%n+1;
        if (l>r) swap(l,r);
        int x=ef(l);
        lastans=tree1.query(tree1.root[x],1,n+1,l,r);
        printf("%d\n",lastans);
    }
    return 0;
}