BZOJ 4568。

感覺很板。

前置技能：線性基。 放一篇感覺講的比較豐富的博客： 戳這裏。

首先要求在一個序列中任意選點使得異或和最大，當然是想到線性基了。

把問題轉換到樹上，如果每次詢問的序列是兩點之間的路徑，也就是說我們只要提取出樹上一條路徑的線性基就可以了吧。

發現線性基滿足可以快速合並這個性質，如果要合並的話只要把一個暴力插到另一個裏面去就行了，這樣是兩個$log$，我們還可以啟發式合並，把小的插到大的裏面去，這樣會更快。

所以我們發現可以鏈剖或者倍增來維護這個東西，我這麽懶，當然是倍增了。

註意倍增的時候是點形成的集合而不是邊形成的集合。

再提兩句：

　　1、線性基並不滿足區間可減性，所以大力可持久化應該是不行的。

　　2、點分治可以減少一個$log$，再用$tarjan$求一求$lca$會更快。

時間復雜度$O(nlog^3n)$。

Code：

#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;

const int N = 20005;
const int B = 62;
const int Lg = 16;

int n, qn, tot = 0, head[N], dep[N], fa[N][Lg];
ll a[N];

struct
 
 Edge {
    int to, nxt;
} e[N << 1];

inline void add(int from, int to) {
    e[++tot].to = to;
    e[tot].nxt = head[from];
    head[from] = tot;
}

template <typename T>
inline void read(T &X) {
    X = 0; char ch = 0; T op = 1;
    for(; ch > ‘9‘ || ch < ‘0‘; ch = getchar())
        
 
if(ch == ‘-‘) op = -1;
    for(; ch >= ‘0‘ && ch <= ‘9‘; ch = getchar())
        X = (X << 3) + (X << 1) + ch - 48;
    X *= op;
}

struct Lp {
    ll p[B]; int cnt;
    
    inline void init() {
        cnt = 0;
        memset(p, 0LL, sizeof(p));
    }
    
    inline void ins(ll val) {
        for(int i = 60; i >= 0; i--) {
            if((val >> i) & 1) {
                if(!p[i]) {
                    p[i] = val;
                    ++cnt;
                    break;
                }
                val ^= p[i];
            }
        }
    }
    
    inline ll getMax() {
        ll res = 0LL;
        for(int i = 60; i >= 0; i--) 
            if((res ^ p[i]) > res) res ^= p[i];
        return res;
    }
    
} s[N][Lg];

inline Lp merge(Lp u, Lp v) {
    Lp res; res.init();
    if(u.cnt > v.cnt) {
        res = u;
        for(int i = 60; i >= 0; i--) {
            if(!v.p[i]) continue;
            res.ins(v.p[i]);
        }
    } else {
        res = v;
        for(int i = 60; i >= 0; i--) {
            if(!u.p[i]) continue;
            res.ins(u.p[i]);
        }
    }
    return res;
}

inline void swap(int &x, int &y) {
    int t = x; x = y; y = t;
}

void dfs(int x, int fat, int depth) {
    fa[x][0] = fat, dep[x] = depth;
    s[x][0].init();
    if(fat) s[x][0].ins(a[fat]);
    for(int i = 1; i <= 15; i++) {
        fa[x][i] = fa[fa[x][i - 1]][i - 1];
        s[x][i] = merge(s[x][i - 1], s[fa[x][i - 1]][i - 1]);
    }
    for(int i = head[x]; i; i = e[i].nxt) {
        int y = e[i].to;
        if(y == fat) continue;
        dfs(y, x, depth + 1);
    }
}

inline Lp getLp(int x, int y) {
    Lp res; res.init();
    res.ins(a[x]), res.ins(a[y]);
    if(dep[x] < dep[y]) swap(x, y);
    for(int i = 15; i >= 0; i--) 
        if(dep[fa[x][i]] >= dep[y]) {
            res = merge(res, s[x][i]);
            x = fa[x][i];
        }
    if(x == y) return res;
    for(int i = 15; i >= 0; i--) 
        if(fa[x][i] != fa[y][i]) {
            res = merge(res, s[x][i]), res = merge(res, s[y][i]);
            x = fa[x][i], y = fa[y][i];
        }
    res = merge(res, s[x][0]), res = merge(res, s[y][0]);
    return res;
}

inline void solve(int x, int y) {
    Lp res = getLp(x, y);
    printf("%lld\n", res.getMax());
}

int main() {
    read(n), read(qn);
    for(int i = 1; i <= n; i++) read(a[i]);
    for(int x, y, i = 1; i < n; i++) {
        read(x), read(y);
        add(x, y), add(y, x);
    }
    
    dfs(1, 0, 1);
    
    for(int x, y; qn--; ) {
        read(x), read(y);
        solve(x, y);
    }
    
    return 0;
}

唔，Linear Basis居然被我寫成了Lp……無話可說

Luogu 3292 [SCOI2016]幸運數字