Bzoj 3166 [Heoi2013] Alo 题解

3166: [Heoi2013]Alo

Time Limit: 20 Sec  Memory Limit: 256 MB
Submit: 1118  Solved: 518
[Submit][Status][Discuss]

Description

Welcome to ALO ( Arithmetic and Logistic Online)。这是一个VR MMORPG ，
如名字所见，到处充满了数学的谜题。
现在你拥有n颗宝石，每颗宝石有一个能量密度，记为ai，这些宝石的能量
密度两两不同。现在你可以选取连续的一些宝石（必须多于一个）进行融合，设为  ai, ai+1, …, a j，则融合而成的宝石的能量密度为这些宝石中能量密度的次大值
与其他任意一颗宝石的能量密度按位异或的值，即，设该段宝石能量密度次大值
为k，则生成的宝石的能量密度为max{k xor ap | ap ≠ k , i ≤ p ≤ j}。 
现在你需要知道你怎么选取需要融合的宝石，才能使生成的宝石能量密度最大。

Input

第一行，一个整数 n，表示宝石个数。 
第二行， n个整数，分别表示a1至an，表示每颗宝石的能量密度，保证对于i ≠ j有 ai ≠ aj。

Output

输出一行一个整数，表示最大能生成的宝石能量密度。

Sample Input

5
9 2 1 4 7

Sample Output

14

HINT

【样例解释】

选择区间[1,5]，最大值为 7 xor 9。 
对于 100%的数据有 1 ≤ n ≤ 50000, 0 ≤ ai ≤ 10^9

Source

加强型数据By Hta

　　又是一道大坑啊……

　　习惯了求区间最大值，区间次大值怎么求呢？本题的n并不允许我们枚举区间，因此我们需要去求出每一个点的可选范围。既然该点是作为次大值出现在区间里，那么我们就要保证区间里有且只有一个比他大的。那么，他的取值范围就是他向左数第2个比他大的数+1～他向右数第2个比他大的数-1。当时看黄学长的时候黄学长说“前驱的前驱”脑子没反应过来，还以为是对他的前驱而言的前驱……

　　区间知道了，那么怎么求最大值呢？如果说这道题我们不需要求这么多次区间异或最大值我们可以使用01trie树进行贪心。然而，由于这里我们要求好多次，普通的01trie并没有什么用，我们需要的是一个支持区间求异或最大值的数据结构——可持久化01trie.

　　其实可持久化01trie打起来和不带修改的主席树没有太大的差别。毕竟都是二叉树。如果没有打过可以先去打一下主席树的模板题，求区间第K大。

　　插入操作基本不变。在查询的时候我们利用前缀和，能让他异或后该位为1，且在这个区间里有满足要求的数，我们就选上并且沿着trie树向那个方向走，否则就向另一个方向走，可以把它理解为一个特殊的在trie树上的dfs。

 #include <iostream>
 #include <cstdlib>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <queue>
 #include <set>
 #include <vector>
 #define N 50006
 #define lowbit(x) (x&(-x))
 using namespace std;
 int n,a[N],b[N];
 set<int> q;
 struct node{
     int size;
     node* ch[];
     node() {
         size=;
         ch[]=ch[]=;
     }
 }*null=new node(),*root[N];
 node* newnode()
 {
     node* x=new node();
     x->ch[]=x->ch[]=null;
     return x;
 }
 void insert(node* la,node* now,int js,int x)
 {
     now->size=la->size+;
     if(!js)return;
     if(x&(1ll<<(js-)))
     {
         now->ch[]=la->ch[];
         now->ch[]=newnode();
         insert(la->ch[],now->ch[],js-,x);
     }
     else
     {
         now->ch[]=la->ch[];
         now->ch[]=newnode();
         insert(la->ch[],now->ch[],js-,x);
     }
 }
 long long que(node* l,node* r,int x)
 {
     long long ans=;
     for(int i=;i>=;i--)
     {
         if(x&(1ll<<(i-)))
         {
             if(r->ch[]->size-l->ch[]->size)
             {
                 ans|=(1ll<<(i-));
                 l=l->ch[];
                 r=r->ch[];
             }
             else
             {
                 r=r->ch[];
                 l=l->ch[];
             }
         }
         else
         {
             if(r->ch[]->size-l->ch[]->size)
             {
                 ans|=(1ll<<(i-));
                 l=l->ch[];
                 r=r->ch[];
             }
             else
             {
                 r=r->ch[];
                 l=l->ch[];
             }
         }
     }
     return ans;
 }
 bool px(int x,int y)
 {
     return a[x]>a[y];
 }
 int main()
 {
     null->ch[]=null->ch[]=null;
     root[]=newnode();
     scanf("%d",&n);
     for(int i=;i<=n;i++)
     {
         root[i]=newnode();
         scanf("%d",&a[i]);
         insert(root[i-],root[i],,a[i]);
         b[i]=i;
     }
     sort(b+,b+n+,px);
     long long ans=;
     q.insert(-);q.insert(-);
     q.insert();q.insert();
     q.insert(b[]);
     for(int i=;i<=n;i++)
     {
         set<int>::iterator it,p;
         p=it=q.lower_bound(b[i]);
         int r,l;
         it++;r=*it-;
         p--;p--; l=*p+;
         l=max(l,);r=min(r,n);
         if(l!=r)ans=max(ans,que(root[l-],root[r],a[b[i]]));
         q.insert(b[i]);
     }
     printf("%lld\n",ans);
     return ;
 }