【BZOJ3166】Alo 可持久化trie树

首先我们枚举次大值，然后确定以这个数为次大值的最大区间。

这个区间就是左边第二个比它大的数的下标+1，右边第二个比它大的数的下标-1。

难就难在找到这个区间。

我们考虑将数排序，然后从大到小将数原来的下标插入set，此时set里的值都大于等于当前插入的数。

所以利用set找到前驱的前驱，后继的后继，就是我们需要的区间。

找到区间后，剩下的就是对于一个给定的数，在一段区间里找到一个数使其异或值最大，直接用可持久化trie就可以了。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>

using namespace std;

const int N = 100000 + 5;
const int len = 30;

namespace Trie{
    int tot, root[N];
    int son[N*50][2], cnt[N*50];
    void insert( int y, int &x, int num, int d ){
        cnt[x = ++tot] = cnt[y]+1;
        if ( d < 0 ) return;
        int p = (num>>d)&1;
        son[x][p^1] = son[y][p^1];
        insert(son[y][p],son[x][p],num,d-1);
    }
    int query( int x, int y, int num, int d ){
        if ( d < 0 ) return 0;
        int p = (num>>d)&1;
        int k = cnt[son[y][p^1]]-cnt[son[x][p^1]];
        if ( k ) return query(son[x][p^1],son[y][p^1],num,d-1)+(1<<d);
        else return query(son[x][p],son[y][p],num,d-1);
    }
}

using namespace Trie;

int n, ans, w[N], k[N];

set <int> s;
set <int> ::iterator it;

bool cmp( const int &A, const int &B ){
    return w[A] > w[B];
}

int Getl( int x ){
    it = s.find(x);
    if ( it-- == s.begin() ) return 0;
    if ( it-- == s.begin() ) return 0;
    return *it;
}
int Getr( int x ){
    it = s.find(x);
    if ( ++it == s.end() ) return n+1;
    if ( ++it == s.end() ) return n+1;
    return *it;
}

int main(){
    scanf( "%d", &n );
    for ( int i = 1; i <= n; i ++ )    scanf( "%d", &w[i] );
    for ( int i = 1; i <= n; i ++ )    k[i] = i;
    sort( k + 1 , k + 1 + n , cmp );
    for ( int i = 1; i <= n; i ++ )
        insert(root[i-1],root[i],w[i],len);    
    s.insert(k[1]);
    for ( int i = 2; i <= n; i ++ ){
        s.insert(k[i]);
        int l = Getl(k[i]);
        int r = Getr(k[i]);
        int x = w[k[i]];
        int temp = query(root[l],root[r-1],x,len);
        ans = max( ans,temp );
    }
    printf( "%d\n", ans );    

    return 0;
}