[HNOI 2015]接水果

Description

风见幽香非常喜欢玩一个叫做 osu!的游戏，其中她最喜欢玩的模式就是接水果。

由于她已经DT FC 了The big black,  她觉得这个游戏太简单了，于是发明了一个更

加难的版本。首先有一个地图，是一棵由 n 个顶点、n-1 条边组成的树（例如图 1

给出的树包含 8 个顶点、7 条边）。这颗树上有 P 个盘子，每个盘子实际上是一条

路径（例如图 1 中顶点 6 到顶点 8 的路径），并且每个盘子还有一个权值。第 i 个

盘子就是顶点a_i到顶点b_i的路径(由于是树，所以从a_i到b_i的路径是唯一的)，

权值为c_i。接下来依次会有Q个水果掉下来，每个水果本质上也是一条路径，第

i 个水果是从顶点 u_i 到顶点v_i 的路径。幽香每次需要选择一个盘子去接当前的水

果：一个盘子能接住一个水果，当且仅当盘子的路径是水果的路径的子路径（例如

图1中从 3到7 的路径是从1到8的路径的子路径）。这里规定:从a 到b的路径与

从b到 a的路径是同一条路径。当然为了提高难度，对于第 i 个水果，你需要选择

能接住它的所有盘子中，权值第 k_i 小的那个盘子，每个盘子可重复使用（没有使用次数

的上限：一个盘子接完一个水果后，后面还可继续接其他水果，只要它是水

果路径的子路径）。幽香认为这个游戏很难，你能轻松解决给她看吗？ 

Input

第一行三个数 n和P 和Q，表示树的大小和盘子的个数和水果的个数。 

接下来n-1 行，每行两个数 a、b，表示树上的a和b 之间有一条边。树中顶点

按1到 n标号。 接下来 P 行，每行三个数 a、b、c，表示路径为 a 到 b、权值为 c 的盘子，其

中0≤c≤10^9，a不等于b。 

接下来Q行，每行三个数 u、v、k，表示路径为 u到 v的水果，其中 u不等于v，你需要选择第 k小的盘子，

第k 小一定存在。 

Output

 对于每个果子，输出一行表示选择的盘子的权值。 

Sample Input

10 10 10 
1 2 
2 3 
3 4 
4 5 
5 6 
6 7 
7 8 
8 9 
9 10 
3 2 217394434 
10 7 13022269 
6 7 283254485 
6 8 333042360 
4 6 442139372 
8 3 225045590 
10 4 922205209 
10 8 808296330 
9 2 486331361 
4 9 551176338 
1 8 5 
3 8 3 
3 8 4 
1 8 3 
4 8 1 
2 3 1 
2 3 1 
2 3 1 
2 4 1 
1 4 1 

Sample Output

442139372 
333042360 
442139372 
283254485 
283254485 
217394434 
217394434 
217394434 
217394434 
217394434 

HINT

N,P,Q<=40000。

题解

（部分内容来自thy_asdf）

我们考虑如果这个题不出在树上，而在序列上，很容易想到用$cdq$来解决。

我们想办法将树拍成一条链，通常办法是$dfs$序（其实树剖的实质也是$dfs$序），再试图找到他们之间的$dfs$序关系。

对于一条路径的子路径，在有根树上只有两种情况。我们分别考虑两种情况（记号说明：$dfn_u$表示$u$的$dfs$序，$last_u$表示以$u$为根的子树中$dfs$序最大的值）：

1. 子路径经过整条路径的$lca$：

如上图所示，假设子路径$u<->v$在路径$a<->b$上。显然$a,b$分别在以$u,v$为根的子树中。

不妨设$dfn_u<=dfn_v$,$dfn_a<=dfn_b$，由$dfs$序的性质，显然存在不等式：$dfn_u<=dfn_a<=last_u$，$dfn_v<=dfn_b<=last_v$。

2. 子路径不经过整条路径的$lca$：

我们记节点$u$在路径$u<->v$上的儿子是$w$。

同样的，容易发现，路径$a<->b$若包含$u<->v$肯定需要$a$或$b$其中一个是在以$v$为根的子树中。不妨假设这个点是$a$。

那么$b$应满足：不在以$w$为根的子树中即可。

显然就有$dfn_v<=dfn_a<=last_v$，$1<=dfn_b<=dfn_w-1 \cup last_w+1<=dfn_b<=n$。

那么现在题目就转化成了不等式之间的关系，考虑$cdq$，我们需要解决的问题就是一个实数对$(dfn_a,dfn_b)$满足不等式组的个数。

继续转化，将需要同时满足的两个不等式抽象成二位空间内的一个矩形，只要点$(dfn_a,dfn_b)$在某个矩形内，就能满足这个不等式组。

现在，整个题目就是覆盖一个点的矩形中权值第$k$小的权值是多少。

将矩形按权值从小到大排序，用扫描线的思想，树状数组区间修改即可。

//It is made by Awson on 2017.12.30
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <vector>
#include <cstdio>
#include <string>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define LD long double
#define Max(a, b) ((a) > (b) ? (a) : (b))
#define Min(a, b) ((a) < (b) ? (a) : (b))
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int N = 80000;

int n, p, q, ans[N+5];
int st[N+5], ed[N+5];
namespace LCA {
    struct tt {
    int to, next;
    }edge[(N<<1)+5];
    int path[N+5], tot, u, v, dfn;
    int top[N+5], size[N+5], son[N+5], fa[N+5], dep[N+5];
    void add(int u, int v) {
    edge[++tot].to = v;
    edge[tot].next = path[u];
    path[u] = tot;
    }
    void dfs1(int u, int father, int depth) {
    fa[u] = father, size[u] = 1, dep[u] = depth;
    for (int i = path[u]; i; i = edge[i].next)
        if (edge[i].to != father) {
        dfs1(edge[i].to, u, depth+1);
        size[u] += size[edge[i].to];
        if (size[edge[i].to] >= size[son[u]]) son[u] = edge[i].to;
        }
    }
    void dfs2(int u, int tp) {
    top[u] = tp; st[u] = ++dfn;
    if (son[u]) dfs2(son[u], tp);
    for (int i = path[u]; i; i = edge[i].next)
        if (edge[i].to != fa[u] && edge[i].to != son[u])
        dfs2(edge[i].to, edge[i].to);
    ed[u] = dfn;
    }
    int get_son(int u, int v) {
    int last = 0;
    while (top[u] != top[v]) {
        last = top[v];
        v = fa[last];
    }
    return u == v ? last : son[u];
    }
    int query(int u, int v) {
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        u = fa[top[u]];
    }
    return dep[u] < dep[v] ? u : v;
    }
    void main() {
    for (int i = 1; i < n; i++) {
        scanf("%d%d", &u, &v);
        add(u, v), add(v, u);
    }
    dfs1(1, 0, 1); dfs2(1, 1);
    }
}
namespace CDQ {
    struct tt {
    int x1, x2, y1, y2, k;
    tt() {
    }
    tt(int _x1, int _x2, int _y1, int _y2, int _k) {
        x1 = _x1, y1 = _y1, x2 = _x2, y2 = _y2, k = _k;
    }
    bool operator < (const tt &b) const {
        return k < b.k;
    }
    }opt[N+5];
    struct ss {
    int x, y, k, id;
    ss() {
    }
    ss(int _x, int _y, int _k, int _id) {
        x = _x, y = _y, k = _k, id = _id;
    }
    bool operator < (const ss &b) const {
        return x < b.x;
    }
    }query[N+5], qu1[N+5], qu2[N+5];
    int u, v, k, P;
    struct ttt {
    int x, y, val;
    ttt() {
    }
    ttt(int _x, int _y, int _val) {
        x = _x, y = _y, val = _val;
    }
    bool operator < (const ttt &b) const {
        return x < b.x;
    }
    }doit[(N<<1)+5];
    struct bit_tree {
    int c[N+5];
    void add(int x, int val) {
        for (; x <= n; x += lowbit(x)) c[x] += val;
    }
    int count(int x) {
        int ans = 0;
        for (; x; x -= lowbit(x)) ans += c[x];
        return ans;
    }
    }T;
    void solve(int ql, int qr, int pl, int pr) {
     if (pl == pr) {
        for (int i = ql; i <= qr; i++) ans[query[i].id] = opt[pl].k;
        return;
    }
    int mid = (pl+pr)>>1, cnt = 0, pos = 0, q1 = 0, q2 = 0;
    for (int i = pl; i <= mid; i++) {
        doit[++cnt] = ttt(opt[i].x1, opt[i].y1, 1);
        doit[++cnt] = ttt(opt[i].x1, opt[i].y2+1, -1);
        doit[++cnt] = ttt(opt[i].x2+1, opt[i].y1, -1);
        doit[++cnt] = ttt(opt[i].x2+1, opt[i].y2+1, 1);
    }
    sort(doit+1, doit+1+cnt);
    for (int i = ql; i <= qr; i++) {
        while (pos < cnt && doit[pos+1].x <= query[i].x) pos++, T.add(doit[pos].y, doit[pos].val);
        int tmp = T.count(query[i].y);
         if (query[i].k <= tmp) qu1[++q1] = query[i];
        else query[i].k -= tmp, qu2[++q2] = query[i];
    }
    while (pos < cnt) pos++, T.add(doit[pos].y, doit[pos].val);
    for (int i = 1; i <= q1; i++) query[i+ql-1] = qu1[i];
    for (int i = 1; i <= q2; i++) query[i+q1+ql-1] = qu2[i];
    if (q1) solve(ql, ql+q1-1, pl, mid);
    if (q2) solve(ql+q1, qr, mid+1, pr);
    }
    void main() {
    for (int i = 1; i <= p; i++) {
        scanf("%d%d%d", &u, &v, &k);
        if (st[u] > st[v]) swap(u, v);
        int w = LCA::query(u, v);
        if (u == w) {
        w = LCA::get_son(u, v);
        if (st[w] > 1) opt[++P] = tt(1, st[w]-1, st[v], ed[v], k);
        if (ed[w] < n) opt[++P] = tt(st[v], ed[v], ed[w]+1, n, k);
        }else opt[++P] = tt(st[u], ed[u], st[v], ed[v], k);
    }
    p = P;
    for (int i = 1; i <= q; i++) {
        scanf("%d%d%d", &u, &v, &k);
        if (st[u] > st[v]) swap(u, v);
        query[i] = ss(st[u], st[v], k, i);
    }
    sort(opt+1, opt+1+p); sort(query+1, query+1+q);
        solve(1, q, 1, p);
    }
}

void work() {
    scanf("%d%d%d", &n, &p, &q);
    LCA::main();
    CDQ::main();
    for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
int main() {
    work();
    return 0;
}