【bzoj2588/P2633】count on a tree —

（以下是luogu题面）

题目描述

给定一棵N个节点的树，每个点有一个权值，对于M个询问(u,v,k)，你需要回答u xor lastans和v这两个节点间第K小的点权。其中lastans是上一个询问的答案，初始为0，即第一个询问的u是明文。

输入输出格式

输入格式：

第一行两个整数N,M。

第二行有N个整数，其中第i个整数表示点i的权值。

后面N-1行每行两个整数(x,y)，表示点x到点y有一条边。

最后M行每行两个整数(u,v,k)，表示一组询问。

输出格式：

M行，表示每个询问的答案。

说明

HINT：

N,M<=100000

思路：

　　一看到静态第K小，你就要想到主席树；一看到树，你就要树链剖分。

　　的确用树剖把树搞成区间，在上面架主席树是比较直接的想法。问题是树剖把链所划分成的区间的数目是不确定的，因此树剖能维护的一般是能够对每条链独立求出，再用结合律结合得出答案的信息。但是主席树需要用确定多的几棵前缀权值树维护一个虚拟的树，查询函数每次传入的参数最好是一样多的。我猜树剖可以写，但是实在太麻烦，而且还多一个log。

　　我们需要维护的其实只是两点之间简单路径的信息，联想到用树上差分实现树链修改的过程，我们可以用主席树维护一个类似于前缀的东西：定义root[i]表示从原树根节点到点i的路径上的权值线段树的根。每棵新树基于的原始版本是它父亲u的那棵树。这个思想与区间前缀和的关系就好比字符串之于Trie树（可能这么比喻也不恰当）。按dfs序建立这样的主席树之后，我们查询的树上路径可以这样求出：

　　设S[l, r]维护从l到r路径的值域信息的线段树，则

　　　　S[u, v] = S[root, u] + S[root, v] - S[root, lca(u, v)] - S[root, father(lca(u, v))]

　　可以看到这个形式与树上节点信息差分很像。那么我们还需要维护LCA的查询。（终于可以用树剖辣！@w@……不，你不想）

　　（倍增大法好

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cctype>
#define BUG puts("$$$")
#define LG 17
#define maxn 100010
template <class T>
void read(T &x) {
x = 0;
char ch = getchar();
while (!isdigit(ch))
ch = getchar();
while (isdigit(ch)) {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
}
using namespace std;
struct E {
int to, nxt;
} edge[maxn << 1];
int head[maxn], top;
int n, m;
int a[maxn], N, st[maxn];
inline void insert(int u, int v) {
edge[++top] = (E) {v, head[u]};
head[u] = top;
}
namespace LCA {
int f[LG + 2][maxn], d[maxn];
void dfs(int u, int pre) {
d[u] = d[pre] + 1;
f[0][u] = pre;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v != pre)
dfs(v, u);
}
}
void init1() {
dfs(1, 0);
for (int k = 1; k <= LG; ++k)
for (int i = 1; i <= n; ++i)
f[k][i] = f[k-1][f[k-1][i]];
}
void swim(int &x, int d) {
for (int i = 0; d; d >>= 1, ++i)
if (d & 1)
x = f[i][x];
}
int find(int u, int v) {
if (d[u] > d[v]) swap(u, v);
swim(v, d[v] - d[u]);
if (u == v)
return u;
for (int k = LG; k >= 0; --k)
if (f[k][u] != f[k][v])
u = f[k][u], v = f[k][v];
return f[0][u];
}
} using namespace LCA;
namespace President_tree {
#define lc(i) seg[i].lc
#define rc(i) seg[i].rc
#define mid ((l + r) >> 1)
int root[maxn], tot;
struct node {
int cnt, lc, rc;
} seg[maxn * 30];
inline void update(int nd) {
seg[nd].cnt = seg[lc(nd)].cnt + seg[rc(nd)].cnt;
}
int build(int l, int r) {
int nd = ++tot;
seg[nd].cnt = 0;
if (l == r)
return nd;
lc(nd) = build(l, mid);
rc(nd) = build(mid + 1, r);
return nd;
}
int modify(int pre, int l, int r, int x) {
int nd = ++tot;
seg[nd] = seg[pre];
if (l == r) {
++seg[nd].cnt;
return nd;
}
if (x <= mid)
lc(nd) = modify(lc(pre), l, mid, x);
else rc(nd) = modify(rc(pre), mid + 1, r, x);
update(nd);
return nd;
}
void init2(int u, int pre) {
root[u] = modify(root[pre], 1, N, a[u]);
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v != pre)
init2(v, u);
}
}
int query(int u, int v, int lca, int flca, int l, int r, int k) {
if (l == r) {
return st[l];
}
int lsum = seg[lc(u)].cnt + seg[lc(v)].cnt - seg[lc(lca)].cnt - seg[lc(flca)].cnt;
if (k <= lsum)
return query(lc(u), lc(v), lc(lca), lc(flca), l, mid, k);
return query(rc(u), rc(v), rc(lca), rc(flca), mid + 1, r, k - lsum);
}
} using namespace President_tree;
int contra(int* a) {
for (int i = 1; i <= n; ++i)
st[i] = a[i];
sort(st + 1, st + 1 + n);
int len = unique(st + 1, st + 1 + n) - st - 1;
for (int i = 1; i <= n; ++i)
a[i] = lower_bound(st + 1, st + len + 1, a[i]) - st;
return len;
}
int main() {
read(n), read(m);
int u, v;
for (int i = 1; i <= n; ++i)
read(a[i]);
N = contra(a);
for (int i = 1; i < n; ++i) {
read(u), read(v);
insert(u, v), insert(v, u);
}
init1();
init2(1, 0);
int k, ans = 0;
for (int i = 1; i <= m; ++i) {
read(u), read(v), read(k);
u = ans xor u;
int lca = find(u, v);
ans = query(root[u], root[v], root[lca], root[f[0][lca]], 1, N, k);
printf("%d\n", ans);
}
return 0;
}