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[N], mp[N], head[N];
int dep[N], top[N], fa[N], siz[N], son[N];
int rt[N], 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;
}