BZOJ2741 【FOTILE模拟赛】L

一个上午两道题，妥妥的作死。。。

首先还是按照之前思路建立可持久化trie，然后发现了点问题。。。

trie只能支持对于给定v求出最大xor值，也就是说我们要枚举a[i] (i ∈ [l, r])，于是单次询问复杂度O(n * 30)，爆表

于是想到了需要预处理，方法是分块，预处理复杂度O(n * (n / sz) * 30)，单次询问复杂度O(sz * 30)（sz为块的大小）

到这里的时候。。。网上的题解君们就只剩下程序了。。。于是害得蒟蒻理解错惹%>_<%

于是看到了BLADEVIL的题解，简直一目了然（但是程序注释不删不敢恭维= =）

重点要注意的就两个地方：

（1）f[i][j]为从第i个块的第一个元素开始，到第j个数的区间中，任意找两个数的xor值最大

（2）在计算l和r的时候。。。会爆int

/**************************************************************
    Problem: 2741
    User: rausen
    Language: C++
    Result: Accepted
    Time:5768 ms
    Memory:11508 kb
****************************************************************/
 
#include <cstdio>
#include <cmath>
#include <algorithm>
 
using namespace std;
typedef long long ll;
const int N = 12005;
const int sqrt_N = 120;
 
struct trie_node {
    int son[2], cnt;
} t[N * 35];
int cnt_trie = 1;
 
int n, m, a[N];
int root[N], sz, w[N];
int f[sqrt_N][N];
 
inline int read() {
    int x = 0;
    char ch = getchar();
    while (ch < '0' || '9' < ch)
        ch = getchar();
    while ('0' <= ch && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x;
}
 
int A[35];
void insert(int &root, int v) {
    int R = root, now = ++cnt_trie, i;
    root = now;
    for (i = 0; i <= 30; ++i)
        A[i] = v & 1, v >>= 1;
    reverse(A, A + 31);
    for (i = 0; i <= 30; ++i) {
        t[now].son[0] = t[R].son[0], t[now].son[1] = t[R].son[1];
        R = t[R].son[A[i]], now = t[now].son[A[i]] = ++cnt_trie;
        t[now].cnt = t[R].cnt + 1;
    }
}
 
int query(int x, int y, int v) {
    int i, res = 0;
    for (i = 0; i <= 30; ++i)
        A[i] = v & 1, v >>= 1;
    reverse(A, A + 31);
    for (i = 0; i <= 30; ++i) {
        if (t[t[y].son[!A[i]]].cnt - t[t[x].son[!A[i]]].cnt)
            x = t[x].son[!A[i]], y = t[y].son[!A[i]], res += (1 << 30 - i);
        else x = t[x].son[A[i]], y = t[y].son[A[i]];
    }
    return res;
}
 
int Query(int l, int r) {
    int i, maxi, res = w[l] < w[r] ? f[w[l] + 1][r] : 0;
    for (i = min(w[l] * sz, r); i >= l; --i)
        res = max(res, query(root[l - 1], root[r], a[i]));
    return res;
}
 
void Block() {
    int i, j, l;
    sz = (int) sqrt(n);
    for (i = 1; i <= n; ++i) {
        w[i] = (int) (i - 1) / sz + 1;
        for (j = 1; j <= w[i]; ++j) {
            l = (j - 1) * sz;
            f[j][i] = max(f[j][i - 1], query(root[l], root[i], a[i]));
        }
    }
}
 
int main() {
    int i, x, y, l, r, last_ans = 0;
    n = read(), m = read();
    for (i = 1, a[0] = root[0] = 0; i <= n; ++i) {
        a[i] = a[i - 1] ^ read(), root[i] = root[i - 1];
        insert(root[i], a[i]);
    }
    Block();
    while (m--) {
        x = read(), y = read();
        l = min(((ll) x + last_ans) % n + 1, ((ll) y + last_ans) % n + 1);
        r = max(((ll) x + last_ans) % n + 1, ((ll) y + last_ans) % n + 1);
        printf("%d
", last_ans = Query(l - 1, r));
    }
    return 0;
}