（LCA+树上主席树）FZU 2237

题意：

多次查询一个树链上的中位数（其实就是求K大）。

分析：

感觉莫队可做，只是不会树上莫队。。

而且这里是边权，处理起来貌似有点小麻烦。。

后来发现其实貌似是一个很老的题，，kuangbin模板书上有类似的题。

树链上的第K大数，这是一道可以用主席树解的题，复杂度才nlogn。

这里也是这样先求从根到每个点的线段树，以为树存在父子关系，所有可以从让下层继承上层的线段树，非常符合主席树的可持久化思想。

然后在查询第K大的时候，去掉重复部分，就可以查了。

太强了，，，

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <set>
#include <vector>
#include <queue>
#include <map>
#include <list>
#include <bitset>
#include <string>
#include <cctype>
#include <cstdlib>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-8)
int sgn(double a) {
    return a < -eps ? -1 : a < eps ? 0 : 1;
}

int n, q;
const int maxn = 50010;
const int m = 100001;
struct Node {
    int v, c;
};

vector<Node>  g[maxn];
const int DEG = 16;
int fa[maxn][DEG];
int deg[maxn];

void addedge(int u, int v, int w) {
    Node a, b;
    a.v = v;
    a.c = w;
    b.v = u;
    b.c = w;
    g[u].push_back(a);
    g[v].push_back(b);
}

void bfs(int root) {
    queue<int> q;
    deg[root] = 0;
    fa[root][0] = root;
    q.push(root);
    while(!q.empty()) {
        int tmp = q.front();
        q.pop();
        for(int i = 1; i < DEG; i++) {
            fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
        }
        for(int i = 0; i < (int)g[tmp].size(); i++) {
            int v = g[tmp][i].v;
            if(v == fa[tmp][0])continue;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            q.push(v);
        }
    }
}

int LCA(int u, int v) {
    if(deg[u] > deg[v])swap(u, v);
    for(int det = deg[v] - deg[u], i = 0; det; det >>= 1, i++) {
        if(det & 1)v = fa[v][i];
    }
    if(u == v)return u;
    for(int i = DEG - 1; i >= 0; i--) {
        if(fa[u][i] != fa[v][i]) {
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}




int T[maxn], lson[maxn * 30], rson[maxn * 30];
int c[maxn * 30];
int tot = 0;

int build(int l, int r) {
    int root = tot++;
    c[root] = 0;
    if(l != r) {
        int mid = (l + r) >> 1;
        lson[root] = build(l, mid);
        rson[root] = build(mid + 1, r);
    }
    return root;
}


int update(int root, int pos, int val) {
    int newroot = tot++, tmp = newroot;
    c[newroot] = c[root] + val;
    int l = 1, r = m;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(pos <= mid) {
            lson[newroot] = tot++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        } else {
            rson[newroot] = tot++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];
            l = mid + 1;
        }
        c[newroot] = c[root] + val;
    }
    return tmp;
}

int query(int u_root, int v_root, int fa_root, int k) {
    int l = 1, r = m;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(c[lson[u_root]] + c[lson[v_root]] - 2 * c[lson[fa_root]] >= k) {
            r = mid;
            u_root = lson[u_root];
            v_root = lson[v_root];
            fa_root = lson[fa_root];
        } else {
            l = mid + 1;
            k -= c[lson[u_root]] + c[lson[v_root]] - 2 * c[lson[fa_root]];
            u_root = rson[u_root];
            v_root = rson[v_root];
            fa_root = rson[fa_root];
        }
    }
    return l;
}



void dfs(int u, int par, int val) {
    T[u] = update(T[par], val, 1);
    for(int i = 0; i < (int)g[u].size(); i++) {
        int v = g[u][i].v;
        if(v == par)continue;
        dfs(v, u, g[u][i].c);
    }
}


void init() {
    for(int i = 1; i <= n; i++) {
        g[i].clear();
    }
    tot = 0;
    memset(fa, 0, sizeof(fa));
}

void solve() {
    while(~scanf("%d%d", &n, &q)) {
        init();
        for(int i = 0; i < n - 1; i++) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            w++;
            addedge(u, v, w);

        }
        bfs(1);
        T[0] = build(1, m);
        dfs(1, 0, 1);
        while(q--) {
            int u, v;
            scanf("%d%d", &u, &v);
            int fa = LCA(u, v);
            int k = (c[T[u]] + c[T[v]] - 2 * c[T[fa]] + 1) / 2;
            printf("%d
", query(T[u], T[v], T[fa], k) - 1);
        }

    }

}



int main() {

#ifndef ONLINE_JUDGE
//    freopen("1.in", "r", stdin);
    //freopen("1.out", "w", stdout);
#endif
    //iostream::sync_with_stdio(false);
    solve();
    return 0;
}