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 = 50005;

int n, num[siz];

int st_maxi[siz][17];

inline void preworkST(void)
{
    for (int i = 1; i <= n; ++i)
        st_maxi[i][0] = num[i];
        
    for (int i = 1; i < 17; ++i)
        for (int j = 1; j <= n; ++j)
            if (j + (1 << i) - 1 <= n)
                st_maxi[j][i] = std::max(
                    st_maxi[j][i - 1],
                    st_maxi[j + (1 << (i - 1))][i - 1]);
}

inline int stMax(int l, int r)
{
    if (l > r)return -1;
    
    int len = r - l + 1, log = 0;
    
    while (len >= (1 << (log + 1)))++log;
    
    return std::max(
        st_maxi[l][log],
        st_maxi[r - (1 << log) + 1][log]);
}

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

inline void preworkNT(void)
{
    for (int i = 1; i <= n; ++i)
    {
        int val = num[i], lt = 1, rt = i, mid, pos = 1, ans = 1;
        
        while (lt <= rt)
        {
            mid = (lt + rt) >> 1;
            
            if (stMax(mid, i) > val)
                lt = mid + 1, pos = mid;
            else
                rt = mid - 1;
        }
        
        lt = 1, rt = pos - 1;
        
        while (lt <= rt)
        {
            mid = (lt + rt) >> 1;
            
            if (stMax(mid, pos - 1) > val)
                lt = mid + 1, ans = mid;
            else
                rt = mid - 1;
        }
        
        nt_pre[i] = ans;
    }
    
    for (int i = 1; i <= n; ++i)
    {
        int val = num[i], lt = i, rt = n, mid, pos = n, ans = n;
        
        while (lt <= rt)
        {
            mid = (lt + rt) >> 1;
            
            if (stMax(i, mid) > val)
                rt = mid - 1, pos = mid;
            else
                lt = mid + 1;
        }
        
        lt = pos + 1, rt = n;
        
        while (lt <= rt)
        {
            mid = (lt + rt) >> 1;
            
            if (stMax(pos + 1, mid) > val)
                rt = mid - 1, ans = mid;
            else
                lt = mid + 1;
        }
        
        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 = 5000005;

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

inline void insert(int t)
{
    int p = 1;
    
    for (int i = 30; i >= 0; --i)
    {
        int c = (t >> i) & 1;
        
        if (!next[p][c])
            next[p][c] = ++tot;
        
        p = next[p][c];
        
        ++sum[p];
    }
}

inline void remove(int t)
{
    int p = 1;
    
    for (int i = 30; i >= 0; --i)
    {
        int c = (t >> i) & 1;
        
        if (!next[p][c])
            next[p][c] = ++tot;
        
        p = next[p][c];
        
        --sum[p];
    }
}

inline int query(int t)
{
    int ret = 0, p = 1;
    
    for (int i = 30; i >= 0; --i)
    {
        int c = (t >> i) & 1;
        
        if (sum[next[p][c^1]])
            p = next[p][c^1], ret |= (1 << i);
        else if (sum[next[p][c]])
            p = next[p][c];
        else 
            return 0;
    }
    
    return ret;
}

signed main(void)
{
    scanf("%d", &n);
    
    for (int i = 1; i <= n; ++i)
        scanf("%d", num + i);
        
    preworkST();
    
    preworkNT();
    
    for (int i = 1; i <= n; ++i)
    {
        q[i].l = nt_pre[i];
        q[i].r = nt_nxt[i];
        q[i].t = num[i];
        q[i].ans = 0;
    }
    
    s = sqrt(n);
    
    std::sort(q + 1, q + 1 + n, cmp);

    int lt = 1, rt = 0, maxi = stMax(1, n);
    
    for (int i = 1; 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 = 0;
    
    for (int i = 1; i <= n; ++i)
        answer = std::max(answer, q[i].ans);
        
    printf("%d
", answer);
}

@Author: YouSiki