BZOJ 3166: [Heoi2013]Alo

3166: [Heoi2013]Alo

Time Limit: 20 Sec  Memory Limit: 256 MB
Submit: 923  Solved: 437
[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

[Submit][Status][Discuss]

首先，应该枚举选择哪个数字作为次大值，然后需要知道其对应的可以选取哪个范围内的数字作为题目中的$ap$。

范围可以通过预处理得到，方法是先用二分得到每个数左侧第一个大于这个数的地方，然后再二分出第二个大于这个数的地方。每个数到两侧第二个大于这个数的范围就是$ap$的可选范围，不含第二个大于这个数的数字。

然后，问题转化为求一个数字在一个区间内的最大异或数字，这个问题是经典的Trie树问题，尽量“反着跑”即可。但是有区间限制，并且是n组询问，所以可以用大佬的可持久化Trie或我这种蒟蒻的莫队+Trie解决。

 #include <bits/stdc++.h>

 const int siz = ;

 int n, num[siz];

 int st_maxi[siz][];

 inline void preworkST(void)
 {
     for (int i = ; i <= n; ++i)
         st_maxi[i][] = num[i];

     for (int i = ; i < ; ++i)
         for (int j = ; j <= n; ++j)
             if (j + ( << i) -  <= n)
                 st_maxi[j][i] = std::max(
                     st_maxi[j][i - ],
                     st_maxi[j + ( << (i - ))][i - ]);
 }

 inline int stMax(int l, int r)
 {
     if (l > r)return -;

     int len = r - l + , log = ;

     while (len >= ( << (log + )))++log;

     return std::max(
         st_maxi[l][log],
         st_maxi[r - ( << log) + ][log]);
 }

 int nt_pre[siz];
 int nt_nxt[siz];

 inline void preworkNT(void)
 {
     for (int i = ; i <= n; ++i)
     {
         int val = num[i], lt = , rt = i, mid, pos = , ans = ;

         while (lt <= rt)
         {
             mid = (lt + rt) >> ;

             if (stMax(mid, i) > val)
                 lt = mid + , pos = mid;
             else
                 rt = mid - ;
         }

         lt = , rt = pos - ;

         while (lt <= rt)
         {
             mid = (lt + rt) >> ;

             if (stMax(mid, pos - ) > val)
                 lt = mid + , ans = mid;
             else
                 rt = mid - ;
         }

         nt_pre[i] = ans;
     }

     for (int i = ; i <= n; ++i)
     {
         int val = num[i], lt = i, rt = n, mid, pos = n, ans = n;

         while (lt <= rt)
         {
             mid = (lt + rt) >> ;

             if (stMax(i, mid) > val)
                 rt = mid - , pos = mid;
             else
                 lt = mid + ;
         }

         lt = pos + , rt = n;

         while (lt <= rt)
         {
             mid = (lt + rt) >> ;

             if (stMax(pos + , mid) > val)
                 rt = mid - , ans = mid;
             else
                 lt = mid + ;
         }

         nt_nxt[i] = ans;
     }
 }

 struct query {
     int l, r, t, ans;
 }q[siz];

 int s;

 inline bool cmp(const query &a, const query &b)
 {
     if (a.l / s != b.l / s)
         return a.l < b.l;
     else
         return a.r < b.r;
 }

 const int tri = ;

 int next[tri][], sum[tri], tot = ;

 inline void insert(int t)
 {
     int p = ;

     for (int i = ; i >= ; --i)
     {
         int c = (t >> i) & ;

         if (!next[p][c])
             next[p][c] = ++tot;

         p = next[p][c];

         ++sum[p];
     }
 }

 inline void remove(int t)
 {
     int p = ;

     for (int i = ; i >= ; --i)
     {
         int c = (t >> i) & ;

         if (!next[p][c])
             next[p][c] = ++tot;

         p = next[p][c];

         --sum[p];
     }
 }

 inline int query(int t)
 {
     int ret = , p = ;

     for (int i = ; i >= ; --i)
     {
         int c = (t >> i) & ;

         if (sum[next[p][c^]])
             p = next[p][c^], ret |= ( << i);
         else if (sum[next[p][c]])
             p = next[p][c];
         else
             return ;
     }

     return ret;
 }

 signed main(void)
 {
     scanf("%d", &n);

     for (int i = ; i <= n; ++i)
         scanf("%d", num + i);

     preworkST();

     preworkNT();

     for (int i = ; i <= n; ++i)
     {
         q[i].l = nt_pre[i];
         q[i].r = nt_nxt[i];
         q[i].t = num[i];
         q[i].ans = ;
     }

     s = sqrt(n);

     std::sort(q + , q +  + n, cmp);

     int lt = , rt = , maxi = stMax(, n);

     for (int i = ; i <= n; ++i)
     {
         while (lt < q[i].l)remove(num[lt++]);
         while (lt > q[i].l)insert(num[--lt]);
         while (rt > q[i].r)remove(num[rt--]);
         while (rt < q[i].r)insert(num[++rt]);
         if (q[i].t != maxi)q[i].ans = query(q[i].t);
     }

     int answer = ;

     for (int i = ; i <= n; ++i)
         answer = std::max(answer, q[i].ans);

     printf("%d\n", answer);
 }

@Author: YouSiki