洛谷P4098 [HEOI2013]ALO

题目链接

[HEOI2013]ALO

题目描述

现在你拥有 n 颗宝石，每颗宝石有一个能量密度，记为 ai，这些宝石的能量 密度两两不同。现在你可以选取连续的一些宝石（必须多于一个）进行融合，设 为 ai, ai+1, …, aj，则融合而成的宝石的能量密度为这些宝石中能量密度的次大值 与其他任意一颗宝石的能量密度按位异或的值，即，设该段宝石能量密度次大值 为 k，则生成的宝石的能量密度为 max{k xor ap | ap ≠ k , i ≤ p ≤ j}

现在你需要知道你怎么选取需要融合的宝石，才能使生成的宝石能量密度最 大

数据范围

$1\le n\le 50000,0\le ai\le 10^9$

样例输入

5 
9 2 1 4 7

样例输出

14

思路分析

由题目可知，取任意长度大于1的区间，区间中取一个次大值和其他任意一个数，使得异或值最大。
所以我们不妨枚举每一个值为次大值的情况。设当前数字左边第一个比它大的数字下标为$l1$，第二个比它大的数字下标为$l2$，右边第一个比他大的数字为$r1$，右边第二个比它大的数字为$r2$。
所以对于当前取的这个数字，我们只需要考虑两个区间 $(l2+1,r1-1]$ 和 $[l1+1,r2-1)$（注意开闭区间）。
那么我们就需要考虑如何在$O(\log n)$或者$O(1)$的情况下求出所需的区间。
这时我们可以使用链表，将元素插入后按从小到大的顺序删除（元素无重复），删除前改元素的左右一共四个元素就是上述的$l1,l2,r1,r2$：

	for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        b[i] = make_pair(a[i], i);	  //记录元素的下标并排序
        L[i] = i - 1, R[i] = i + 1;  //链表初始化
    }
    sort(b + 1, b + 1 + n);
    for (int i = 1; i <= n; i++)
    {
        int x = b[i].second;		 //按顺序取出值
        int l = L[x], r = R[x];      //取出左右两边第一个比自身大的点
        L[r] = l, R[l] = r;          //删除当前已取出的点，把他的左节点指向右节点，右节点指向左节点
    }

我们稍微思考一下，排序取出的数是从小到大的，假如我们第一个取出的数是$1$，那么很明显他左右两边的数都是大于他的，因此我们可以通过链表的前驱后继得到前后比它大的数的位置。然后我们把1删除，也就是它的前驱指向它的后继，它的后继指向它的前驱，那么这个点就被跳过（删除）了，之后我们再取出的点就是此时最小的点，那么他的左右两边正好又是第一个比它自身大的点。以此类推。

注意需要特判区间左右还有没有比它大的元素。
最后我们就可以在得到区间内使用可持久化字典树进行最大值的查询。

AC代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
const int N = 100010;

int n;
int a[N], L[N], R[N];
PII b[N];
int tr[N * 32][2], max_id[N * 32];
int root[N], idx;

//可持久化字典树模板
void insert(int i, int k, int p, int q)
{
    if (k < 0)
    {
        max_id[q] = i;
        return;
    }
    int v = a[i] >> k & 1;
    if (p) tr[q][v ^ 1] = tr[p][v ^ 1];
    tr[q][v] = ++idx;
    insert(i, k - 1, tr[p][v], tr[q][v]);
    max_id[q] = max(max_id[tr[q][0]], max_id[tr[q][1]]);
}

int query(int l, int r, int x)
{
    int p = root[r];
    for (int i = 31; ~i; i--)
    {
        int v = x >> i & 1;
        if (max_id[tr[p][v ^ 1]] >= l) p = tr[p][v ^ 1];
        else p = tr[p][v];
    }
    return x ^ a[max_id[p]];
}

int main()
{
    cin >> n;
    
    //初始化
    max_id[0] = -1;
    root[0] = ++idx;
    insert(0, 31, 0, root[0]);
    
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        b[i] = make_pair(a[i], i);
        L[i] = i - 1, R[i] = i + 1;    //链表初始化
        root[i] = ++idx;
        insert(i, 31, root[i - 1], root[i]);
    }
    
    sort(b + 1, b + 1 + n);
    int res = 0;
    for (int i = 1; i <= n; i++)
    {
        int x = b[i].second;
        int l = L[x], r = R[x];        //取出左右两边第一个比自身大的点
        L[r] = l, R[l] = r;            //删除当前已取出的点，把他的左节点指向右节点，右节点指向左节点
        if (l != 0) res = max(res, query(L[l] + 1, r - 1, a[x]));
        if (r != n + 1) res = max(res, query(l + 1, R[r] - 1, a[x]));
    }
    cout << res << endl;

    return 0;
}