BZOJ 2588 [可持久化线段树][lca]

Description

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

Input

第一行两个整数N,M。

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

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

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

Output

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

n,m≤100000

先来考虑动态区间k大。

只需按权值开一棵可持久化线段树，按时间为版本建树即可。

那么对于两棵线段树rt[l−1]和rt[r]，其中一棵是存入前l−1个数的线段树，另一棵是存入前r个数的线段树。那么size[ls[rt[r]]]−size[ls[rt[l−1]]]就是在区间[l,r]之间≤mid的数的个数。这样就可以求动态区间k大了。

再来考虑树上动态区间k大。

大体方法一致，每一个节点的前一个版本就是它的父亲。对于u,v两个节点，在它们路径之间≤mid的数的个数为sum=size[ls[x]]+size[ls[y]]−size[ls[t]]−size[ls[f]]。

其中x=rt[u],y=rt[v],t=rt[lca(u,v)],f=rt[fa[lca(u,v)]]。

我是用树链剖分来求的lca。

PE了几发，看Discuss才知道最后不能有回车。

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

inline char get(void) {
static char buf[100000], *S = buf, *T = buf;
if (S == T) {
T = (S = buf) + fread(buf, 1, 100000, stdin);
if (S == T) return EOF;
}
return *S++;
}
template<typename T>
inline void read(T &x) {
static char c; x = 0;
for (c = get(); c < '0' || c > '9'; c = get());
for (; c >= '0' && c <= '9'; c = get()) x = x * 10 + c - '0';
}

const int N = 200100;

int v
, mp
, head
;
int dep
, top
, fa
, siz
, son
;
int rt
, ls[N * 20], rs[N * 20], size[N * 20];
int n, m, x, y, Gcnt, mx, Tcnt, lastans, k, F;
struct edge {
int to, next;
edge(int t = 0, int n = 0):to(t), next(n) {}
};
edge G[N * 2];

inline void AddEdge(int from, int to) {
G[++Gcnt] = edge(to, head[from]); head[from] = Gcnt;
G[++Gcnt] = edge(from, head[to]); head[to] = Gcnt;
}

void Insert(int &o, int pos, int l, int r) {
ls[++Tcnt] = ls[o]; rs[Tcnt] = rs[o];
size[Tcnt] = size[o] + 1; o = Tcnt;
if (l == r) return;
int mid = (l + r) >> 1;
if (mid < pos) Insert(rs[o], pos, mid + 1, r);
else Insert(ls[o], pos, l, mid);
}
void dfs1(int u) {
int to; siz[u] = 1;
for (int i = head[u]; i; i = G[i].next) {
to = G[i].to; if (to == fa[u]) continue;
fa[to] = u; dep[to] = dep[u] + 1;
dfs1(to); siz[u] += siz[to];
if (siz[to] > siz[son[u]]) son[u] = to;
}
}
void dfs2(int u, int t) {
int to; top[u] = t;
rt[u] = rt[fa[u]];
Insert(rt[u], v[u], 1, mx);
if (son[u]) dfs2(son[u], t);
for (int i = head[u]; i; i = G[i].next)
if ((to = G[i].to) != fa[u] && to != son[u]) dfs2(to, to);
}
int lca(int x, int y) {
static int f1, f2;
while ((f1 = top[x]) != (f2 = top[y])) {
if (dep[f1] < dep[f2]) {
swap(x, y); swap(f1, f2);
}
x = fa[f1];
}
return dep[x] > dep[y] ? y : x;
}
int Query(int x, int y, int t, int f, int l, int r, int k) {
if (l == r) return l;
int sum = size[ls[x]] + size[ls[y]] - size[ls[t]] - size[ls[f]],
mid = (l + r) >> 1;
if (sum >= k) return Query(ls[x], ls[y], ls[t], ls[f], l, mid, k);
else return Query(rs[x], rs[y], rs[t], rs[f], mid + 1, r, k - sum);
}

int main(void) {
read(n); read(m);
for (int i = 1; i <= n; i++) {
read(v[i]); mp[i] = v[i];
}
sort(mp + 1, mp + n + 1);
mx = unique(mp + 1, mp + n + 1) - mp - 1;
for (int i = 1; i <= n; i++)
v[i] = lower_bound(mp + 1, mp + mx + 1, v[i]) - mp;
for (int i = 1; i < n; i++) {
read(x); read(y);
AddEdge(x, y);
}
dfs1(1); dfs2(1, 1);
for (int i = 1; i <= m; i++) {
read(x); read(y); read(k);
x ^= lastans; F = lca(x, y);
lastans = mp[Query(rt[x], rt[y], rt[F], rt[fa[F]], 1, mx, k)];
printf("%d", lastans);
if (i < m) puts("");
}
return 0;
}