数据结构&字符串：可持久化字典树

利用可持久化Trie树实现范围内取值异或最大值

如果标题没有表达清楚意思，可以看这里的题干：

然后根据异或的性质，异或一个数两次相当于没有异或，那么我们可以维护一个异或前缀和

有了异或前缀和之后我们就可以通过前缀和的形式O（1）提取出任意的一个异或区间出来

然后就可以把题目转化成这样的形式

求max(b[p]^b[n]^x) (l-1<=p<=r-1)

这里只有b[p]是不知道的，我们提前把序列的异或前缀和预处理出来之后插入到可持久化Tire树里面，又因为b[n]和x是定值，这就又转化成上一篇博文中描述的问题了

只不过这里插入到Trie树里面的东西不是独立的，而是一个整体，我们要从这个整体异或中提取出关键的那一个结果来，由于我们的p是限定了范围的，那么这就相当于对应了一系列的前缀和

范围内的每一个结果都是可行的，因此我们凭借着贪心的时候能取最大取最大的思路，如果在当前Trie树里得不到局部最优解，就跳跃到另一颗更优的Trie树上进行就好了

可持久化的思想就是每一个版本的树的儿子之间乱跳

 #include<cstdio>
 const int maxn=;
 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
     return x*f;
 }
 int n,m;
 int a[maxn],b[maxn],bin[],root[maxn];
 struct Trie
 {
     int cnt;
     int ch[maxn*][],sum[maxn*];
     int insert(int x,int val)
     {
         int tmp,y;
         tmp=y=++cnt;
         for(int i=;i>=;i--)
         {
             ch[y][]=ch[x][];
             ch[y][]=ch[x][];
             sum[y]=sum[x]+;
             int t=val&bin[i];t>>=i;
             x=ch[x][t];
             ch[y][t]=++cnt;
             y=ch[y][t];
         }
         sum[y]=sum[x]+;
         return tmp;
     }
     int query(int l,int r,int val)
     {
         int tmp=;
         for(int i=;i>=;i--)
         {
             int t=val&bin[i];t>>=i;
             if(sum[ch[r][t^]]-sum[ch[l][t^]])
                 tmp+=bin[i],r=ch[r][t^],l=ch[l][t^];
             else r=ch[r][t],l=ch[l][t];
         }
         return tmp;
     }
 }trie;
 int main()
 {
     bin[]=;
     for(int i=;i<;i++) bin[i]=bin[i-]<<;
     n=read();m=read();
     n++;
     for(int i=;i<=n;i++) a[i]=read();
     for(int i=;i<=n;i++) b[i]=b[i-]^a[i];
     for(int i=;i<=n;i++)
         root[i]=trie.insert(root[i-],b[i]);
     char ch[];
     int l,r,x;
     while(m--)
     {
         scanf("%s",ch);
         if(ch[]=='A')
         {
             n++;
             a[n]=read();b[n]=b[n-]^a[n];
             root[n]=trie.insert(root[n-],b[n]);
         }
         else
         {
             l=read();r=read();x=read();
             printf("%d\n",trie.query(root[l-],root[r],b[n]^x));
         }
     }
     return ;
 }