SPOJ MAXOR （分块 || 可持久化字典树 || 异或）（好题）

You are given a sequence A[1], A[2], ..., A[N]. (0 ≤ A[i] < 2³¹, 1 ≤ N ≤ 12000).

A query is defined as follows:

Query(x,y) = Max { a[i] xor a[i+1] xor ... xor a[j] ; l ≤ i ≤ j ≤ r }.
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[1] = 0 , lastans[i] = Query[i-1].

Given M queries, your program must output the results of these queries. (0 ≤ M ≤ 6000).

IMPORTANT : PROBLEM ENHANCED. ( I'M SO SORRY.. )

Input

The first line of the input file contains 2 numbers : N M.
In the second line, N numbers follow.
M lines follow, where line i contains 2 numbers xi and yi.

Output

Your program should output the results of the M queries, one query per line.

Example

Input:

3 3

1 4 3

0 1

0 1

4 3

Output:

5

7

7

题目：

对于每个询问，输出[L,R]区间的最大的连续异或值，强制在线。

解法：分块+可持久化字典树

首先，分块，把每个点分属于一个块，belong[i]=(i-1)/sqrt(n) +1;
预处理得到每个块的左边界到右边的点的区间的最大异或，即如果(i-1)%sqrt(n)=0 ，则计算Maxxor[belong[i],j]，(i<=j<=n)（这里很关键，不过先别管这里这么实现的，看完）
对于每个询问[L,R],由于我们预处理得到了[belong[L]+1,R]的最大异或和，现在只要计算[t,R]的最大异或和(L<=t<=belong[L]的右边界)。

-------------------------------------------嗯，看似行得通，怎么实现呢？----------------------------------------

首先，此题的分块没有暴力删除，没有添加等等操作，分块只是为了预处理，的得到多个区间的最大异或和。

对于第二步，我们怎么实现呢，看似复杂度很大。但是我们对于MAXOR[i,j]，充分利用到前面计算的结果,MAXOR[i,j]=max(MAXOR[i,j-1],num[j]^字典树)。

然后问题来了，字典树怎么限定边界呢？ ------可持久化实现。

那么对于每个询问，只有[L,相应块的右边界]需要在持久化Trie里找最大，然后结合预先处理的[L的右边界+1，R]得到结果。

#include<cmath>

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<iostream>

#include<algorithm>

using namespace std;

const int maxn=;

struct nmphy

{

    int n,m,a[maxn],G[][maxn];

    int rt[maxn],sum[maxn*],ch[maxn*][],cnt;

    int B,group[maxn],L;

    int swap(int &u,int &v)  { u^=v; v^=u; u^=v; }

    int Max (int &x,int y)   { if(y>x) x=y;}

    void init()

    {

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

        n++;  int tmp=;

        for(int i=;i<=n;i++){ //这里i==1是为了把a[1]==0加进去。

            scanf("%d",&a[i]);

            a[i]^=a[i-];

            tmp|=a[i];         //得到最长位。

        }

        L=;  while(tmp) L++,tmp>>=; if(!L) L=;

        for(int i=;i<=n;i++) insert(rt[i-],rt[i],a[i],L-);

    }

    void insert(int x,int &y,int val,int pos)

    {

         sum[y=++cnt]=sum[x]+;

         if(pos==)  return ;

         int d=(val>>pos)&;

         ch[y][d^]=ch[x][d^];

         insert(ch[x][d],ch[y][d],val,pos-);

    }

    int query(int x,int y,int val)

    {

        int res=;

        for(int i=L-;i>=;i--){

            int d=(val>>i)&;

            if(sum[ch[y][d^]]-sum[ch[x][d^]]>) {

                 res+=(<<i);

                 x=ch[x][d^];y=ch[y][d^];

            }

            else x=ch[x][d],y=ch[y][d];

        } return res;

    }

    int cal(int x, int y, int v, int d) {

       if (d < ) return ;

       int p = v >> d & ; int tmp = sum[ch[y][p ^ ]] - sum[ch[x][p ^ ]];

       if (tmp > ) return ( << d) + cal(ch[x][p ^ ], ch[y][p ^ ], v, d - );

       else return cal(ch[x][p], ch[y][p], v, d - );

    }

    void divide()

    {

        while(B*B<n) B++;

        for(int i=;i<=n;i++) {

            group[i]=(i-)/B+;

            if((i-)%B==){

                for(int j=i;j<=n;j++){

                     G[group[i]][j]=cal(rt[i],rt[j],a[j],L-);

                     Max(G[group[i]][j],G[group[i]][j-]);

                }

            }

        }

    }

    void solve()

    {

        int ans=,tmp,l,r;

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

        {

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

             l=(l+(long long)ans)%(n-)+;

             r=(r+(long long)ans)%(n-)+;

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

             ans=G[group[l]+][r];

             for(int j=l;j<=r&&group[j]==group[l];j++){

                 tmp=cal(rt[l],rt[r],a[j],L-);

                 Max(ans,tmp);

             }

             printf("%d\n",ans);

        }

    }

}Tree;

int main()

{

    Tree.init();    //输入，持久化Trie树

    Tree.divide();  //分块，预处理块尾到后面的信息。

    Tree.solve();   //快头之后的信息+块头前的暴力。

    return ;

}