【luogu P2633】Count on a tree
Count on a tree
题目链接：luogu P2633
题目大意
有一棵树，每个点有权值。
多个询问，要你求两个点之间形成的链中点权第 k 小的权值。
强制在线。
思路
首先，我们可以看成是一个数组求第 k 小。
那求这个问题，除了暴力，我们很容易想到主席树。
那我们考虑怎么主席树，先考虑怎么弄一棵普通的线段树。
那就像弄静态区间第 k 小那道题一样弄就可以了。
但是考虑怎么弄成主席树的样子，从哪里扩张。
那因为这是棵树，那我们考虑选一个根节点，然后只弄某个点到根节点的那条链。
然后你就弄出了主席树。
那怎么得到一个区间的树呢？
也是大概用那个前缀和的思想，那你自然想到要求 LCA，那问题也不大，求就是了。
那具体怎么弄呢，那就是它们两个点对应的树加起来减上它们 LCA 对应的树再减它们 LCA 的直接父亲对应的树。
用公式来说，对于线段树（主席树）上某个点 \(p\)，那它会在题目的树上的每个点 \(x\) 对应的线段树都有一个值 \(tree_x\)，假设你询问给出的两个点分别是 \(x,y\)，它们的 LCA 点叫做 \(lca\)，那构造出来这个区间对应的线段树上这个点的值就是这个：
\(tree_x+tree_y-tree_{lca}-tree_{fa_{lca}}\)
（\(fa_x\) 就是在题目给出的树上这个点的直接父亲）
这个其实很好理解，就是把两个加起来之后，会有重复的和不要的，那我们就容斥一下，第一个减是减去重复的，第二个减是减去不要的。
那你就可以得到，然后其他操作就跟那道题差不多了。
代码
#include<cstdio>
#include<algorithm>
using namespace std;
struct node {
int to, nxt;
}e[200001];
struct Tree {
int l, r, x, num;
}tree[200001 << 7];
struct point {
int x, num, xx;
}a[200001];
int n, m, le[100001], last_answer;
int KK, tot, dy[100001], k, lca;
int fa[100001][20], tot_num, x, y;
int deg[100001], root[100001];
bool cmp(point x, point y) {
return x.x < y.x;
}
bool cmp_back(point x, point y) {
return x.num < y.num;
}
void lsh() {//离散化
sort(a + 1, a + n + 1, cmp);
a[1].xx = ++tot;
dy[tot] = a[1].x;
for (int i = 2; i <= n; i++) {
if (a[i].x != a[i - 1].x) {
tot++;
dy[tot] = a[i].x;
}
a[i].xx = tot;
}
sort(a + 1, a + n + 1, cmp_back);
}
void add(int x, int y) {
e[++KK] = (node){y, le[x]}; le[x] = KK;
}
void up(int now) {//主席树操作
tree[now].num = tree[tree[now].l].num + tree[tree[now].r].num;
}
int clone(int now) {
tot_num++;
tree[tot_num] = tree[now];
return tot_num;
}
int build(int now, int l, int r) {
now = ++tot_num;
if (l == r) {
tree[now].x = tree[now].num = 0;
return now;
}
int mid = (l + r) >> 1;
tree[now].l = build(tree[now].l, l, mid);
tree[now].r = build(tree[now].r, mid + 1, r);
up(now);
return now;
}
int add_one(int now, int l, int r, int loc) {
now = clone(now);
if (l == r) {
tree[now].x++;
tree[now].num = tree[now].x;
return now;
}
int mid = (l + r) >> 1;
if (loc <= mid) tree[now].l = add_one(tree[now].l, l, mid, loc);
else tree[now].r = add_one(tree[now].r, mid + 1, r, loc);
up(now);
return now;
}
void dfs(int now, int father) {//dfs跑图
fa[now][0] = father;
deg[now] = deg[father] + 1;
root[now] = add_one(root[father], 1, tot, a[now].xx);
for (int i = le[now]; i; i = e[i].nxt)
if (e[i].to != father)
dfs(e[i].to, now);
}
//主席树操作
int get_answer(int now_add1, int now_add2, int now_minus1, int now_minus2, int l, int r, int k) {
if (l == r) {
return dy[l];
}
int mid = (l + r) >> 1;
int lnum = tree[tree[now_add1].l].num + tree[tree[now_add2].l].num - tree[tree[now_minus1].l].num - tree[tree[now_minus2].l].num;
if (k <= lnum) return get_answer(tree[now_add1].l, tree[now_add2].l, tree[now_minus1].l, tree[now_minus2].l, l, mid, k);
else return get_answer(tree[now_add1].r, tree[now_add2].r, tree[now_minus1].r, tree[now_minus2].r, mid + 1, r, k - lnum);
}
int LCA(int x, int y) {//LCA
if (deg[y] > deg[x]) swap(x, y);
for (int i = 17; i >= 0; i--)
if (deg[fa[x][i]] >= deg[y])
x = fa[x][i];
if (x == y) return x;
for (int i = 17; i >= 0; i--)
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
return fa[x][0];
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].x);
a[i].num = i;
}
lsh();
for (int i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
add(x, y);
add(y, x);
}
root[0] = build(0, 1, tot);
dfs(1, 0);
for (int i = 1; i <= 17; i++)//LCA要用的倍增
for (int j = 1; j <= n; j++)
fa[j][i] = fa[fa[j][i - 1]][i - 1];
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &x, &y, &k);
x ^= last_answer;
lca = LCA(x, y);
if (lca == x) last_answer = get_answer(root[y], root[0], root[fa[x][0]], root[0], 1, tot, k);
else if (lca == y) last_answer = get_answer(root[x], root[0], root[fa[y][0]], root[0], 1, tot, k);
else last_answer = get_answer(root[x], root[y], root[lca], root[fa[lca][0]], 1, tot, k);
printf("%d\n", last_answer);
}
return 0;
}
