[SCOI 2016]幸运数字

Description

A 国共有 n 座城市，这些城市由 n-1 条道路相连，使得任意两座城市可以互达，且路径唯一。每座城市都有一个幸运数字，以纪念碑的形式矗立在这座城市的正中心，作为城市的象征。一些旅行者希望游览 A 国。旅行者计划乘飞机降落在 x 号城市，沿着 x 号城市到 y 号城市之间那条唯一的路径游览，最终从 y 城市起飞离开 A 国。

在经过每一座城市时，游览者就会有机会与这座城市的幸运数字拍照，从而将这份幸运保存到自己身上。然而，幸运是不能简单叠加的，这一点游览者也十分清楚。他们迷信着幸运数字是以异或的方式保留在自己身上的。例如，游览者拍了 3 张照片，幸运值分别是 5，7，11，那么最终保留在自己身上的幸运值就是 9（5 xor 7 xor 11）。

有些聪明的游览者发现，只要选择性地进行拍照，便能获得更大的幸运值。例如在上述三个幸运值中，只选择 5 和 11 ，可以保留的幸运值为 14 。现在，一些游览者找到了聪明的你，希望你帮他们计算出在他们的行程安排中可以保留的最大幸运值是多少。

Input

第一行包含 2 个正整数 n ，q，分别表示城市的数量和旅行者数量。第二行包含 n 个非负整数，其中第 i 个整数 Gi 表示 i 号城市的幸运值。随后 n-1 行，每行包含两个正整数 x ，y，表示 x 号城市和 y 号城市之间有一条道路相连。随后 q 行，每行包含两个正整数 x ，y，表示这名旅行者的旅行计划是从 x 号城市到 y 号城市。N<=20000,Q<=200000,Gi<=2^60

Output

输出需要包含 q 行，每行包含 1 个非负整数，表示这名旅行者可以保留的最大幸运值。

Sample Input

4 2
11 5 7 9
1 2
1 3
1 4
2 3
1 4

Sample Output

14
11

题解

线性基+点分治。

这两个都是最近才接触的，正好有道题结合起来了。

我们每次找到重心，处理与重心相关的路径。

处理时我们将重心到每个节点这一段的$xor$存起来，然后找到所有经过重心的路径。

我是在遍历以重心$G$为根的一个子树过程中，找到与这棵子树中节点$u$有关的询问$(u,v)$，判断是否在之前遍历过的以重心为根的其他子树中出现过，如果出现过，我们可以将$G->u$和$G->v$这两段的线性基合并。找到合并后的线性基中的最大值就好了。对于合并，直接暴力拆开一个线性基，一个一个插入到另一个线性基中。

处理完这棵子树之后，再遍历一遍，打上访问过的标记。这样保证所有询问都只计算过一次。

注意，处理完这个重心之后，清空标记时，不要$memset$，直接再遍历一遍就好了，快得多。

值得注意的是，要单独考虑与$G$有关的询问如$(G,v)$，因为重心$G$没标记访问过。（当然了，你可以找完重心后就马上把重心标记访问，效果是一样的，这个询问也只会遍历一次。因为重心是不会被访问的）

另外注意单独考虑$(u,u)$的询问。

 //It is made by Awson on 2017.9.22
 #include <set>
 #include <map>
 #include <ctime>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <vector>
 #include <cstdio>
 #include <string>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 #define sqr(x) ((x)*(x))
 using namespace std;
 const int N = ;
 const int Q = ;
 const int INF = ~0u>>;
 LL st[];
 int Read() {
     int sum = ;
     char ch = getchar();
     while (ch < '' || ch > '') ch = getchar();
     while (ch >= '' && ch <= '') sum = (sum<<)+(sum<<)+ch-, ch = getchar();
     return sum;
 }

 struct base {
     LL a[];
     void insert(LL x) {
     for (int i = ; i >= ; i--)
         if (x&st[i]) {
         if (!a[i]) {
             a[i] = x;
             break;
         }
         else x ^= a[i];
         }
     }
     LL getmax() {
     LL maxn = ;
     for (int i = ; i >= ; i--)
         maxn = Max(maxn, (maxn^a[i]));
     return maxn;
     }
     void clean() {
     for (int i = ; i >= ; i--)
         a[i] = ;
     }
     void copy(base b) {
     for (int i = ; i >= ; i--)
         a[i] = b.a[i];
     }
     void merge(base b) {
     for (int i = ; i >= ; i--) {
         insert(b.a[i]);
     }
     }
 }ba[N+], tmp;
 int n, q, u, v;
 LL g[N+];
 struct tt {
     int to, next;
 }edge[N*+];
 int path[N+], top;
 struct question {
     int v, id, next;
 }que[Q*+];
 int pathq[N+], topq;
 LL ans[Q+];
 int size[N+], mx[N+], minsize, root;
 bool vis[N+];
 bool judge[N+];

 void add(int u, int v) {
     edge[++top].to = v;
     edge[top].next = path[u];
     path[u] = top;
 }
 void addq(int u, int v, int id) {
     que[++topq].v = v;
     que[topq].id = id;
     que[topq].next = pathq[u];
     pathq[u] = topq;
 }
 void get_size(int u, int fa) {
     size[u] = , mx[u] = ;
     for (int i = path[u]; i; i = edge[i].next)
     if (edge[i].to != fa && !vis[edge[i].to]) {
         get_size(edge[i].to, u);
         size[u] += size[edge[i].to];
         mx[u] = Max(mx[u], size[edge[i].to]);
     }
 }
 void get_root(int r, int u, int fa) {
     mx[u] = Max(mx[u], size[r]-size[u]);
     if (mx[u] < minsize) minsize = mx[u], root = u;
     for (int i = path[u]; i; i = edge[i].next)
     if (edge[i].to != fa && !vis[edge[i].to])
         get_root(r, edge[i].to, u);
 }
 void get_ans(int r, int u, int fa) {
     ba[u].copy(ba[fa]);
     ba[u].insert(g[u]);
     for (int i = pathq[u]; i; i = que[i].next)
     if (judge[que[i].v]) {
         tmp.copy(ba[u]);
         tmp.merge(ba[que[i].v]);
         ans[que[i].id] = tmp.getmax();
     }
     else if (que[i].v == r) {
         ans[que[i].id] = ba[u].getmax();
     }
     for (int i = path[u]; i; i = edge[i].next)
     if (edge[i].to != fa && !vis[edge[i].to])
         get_ans(r, edge[i].to, u);
 }
 void get_update(int u, int fa) {
     judge[u] = !judge[u];
     for (int i = path[u]; i; i = edge[i].next)
     if (edge[i].to != fa && !vis[edge[i].to])
         get_update(edge[i].to, u);
 }
 void doit(int x) {
     minsize = INF;
     get_size(x, );
     get_root(x, x, );
     vis[root] = ;
     ba[root].clean();
     ba[root].insert(g[root]);
     for (int i = path[root]; i; i = edge[i].next)
     if (!vis[edge[i].to]) {
         get_ans(root, edge[i].to, root);
         get_update(edge[i].to, root);
     }
     for (int i = path[root]; i; i = edge[i].next)
     if (!vis[edge[i].to])
         get_update(edge[i].to, root);
     for (int i = path[root]; i; i = edge[i].next)
     if (!vis[edge[i].to])
         doit(edge[i].to);
 }
 void work() {
     n = Read(), q = Read();
     for (int i = ; i <= n; i++) scanf("%lld", &g[i]);
     for (int i = ; i < n; i++) {
     u = Read(), v = Read();
     add(u, v), add(v, u);
     }
     for (int i = ; i <= q; i++) {
     u = Read(), v = Read();
     if (u != v) addq(u, v, i), addq(v, u, i);
     else ans[i] = g[u];
     }
     doit();
     for (int i = ; i <= q; i++) printf("%lld\n", ans[i]);
 }
 int main() {
     st[] = ;
     for (int i = ; i < ; i++)
     st[i] = st[i-]<<;
     work();
     return ;
 }