HDU 2586 How far away ？【LCA入门】

There are n houses in the village and some bidirectional roads connecting them. Every day peole always like to ask like this “How far is it if I want to go from house A to house B”? Usually it hard to answer. But luckily int this village the answer is always unique, since the roads are built in the way that there is a unique simple path(“simple” means you can’t visit a place twice) between every two houses. Yout task is to answer all these curious people.
Input
First line is a single integer T(T<=10), indicating the number of test cases.
For each test case,in the first line there are two numbers n(2<=n<=40000) and m (1<=m<=200),the number of houses and the number of queries. The following n-1 lines each consisting three numbers i,j,k, separated bu a single space, meaning that there is a road connecting house i and house j,with length k($0<k<=40000$).The houses are labeled from 1 to n.
Next m lines each has distinct integers i and j, you areato answer the distance between house i and house j.
Output
For each test case,output m lines. Each line represents the answer of the query. Output a bland line after each test case.
Sample Input
2
3 2
1 2 10
3 1 15
1 2
2 3
2 2
1 2 100
1 2
2 1
Sample Output
10
25
100
100

题意：一个村庄，树形结构，问你两个点之间的最短路径；
分析：树上倍增（LCA），找最近公共祖先，路径的和就是最短路径；
倍增LCA

#include <cstdio>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
typedef long long LL;

const int MAXN = 1e5 + 10;
int gw[MAXN][30]；//倍增求路径和
int grand[MAXN][30];//倍增找祖先
int depth[MAXN];//距离根节点的长度
int n, m, N;

struct node {
    int to;
    int cos;
}e;
vector<node> G[MAXN];

inline void dfs(int x, int fa) { //建树
    for(int i = 1; i <= N; ++i) { 
        grand[x][i] = grand[grand[x][i - 1]][i - 1];
        gw[x][i] = gw[x][i - 1] + gw[grand[x][i - 1]][i - 1];
    }
    for(int i = 0; i < G[x].size(); ++i) {
        e = G[x][i];
        if(e.to == fa) continue;
        depth[e.to] = depth[x] + 1;
        grand[e.to][0] = x;
        gw[e.to][0] = e.cos;
        dfs(e.to, x);
    }
}

inline void init() {
    memset(gw, 0, sizeof(gw));
    memset(grand, 0, sizeof(grand));
    memset(depth, 0, sizeof(depth));
    N = floor(log(double(n)) / log(2.0));//最长步数
    dfs(1, -1);
}

inline int lca(int a, int b) {
    if(depth[a] > depth[b]) swap(a, b);
    int ans = 0;
    for(int i = N; i >= 0; --i) {//统一高度
        if(depth[a] < depth[b] && depth[grand[b][i]] >= depth[a]) {
            ans += gw[b][i];
            b = grand[b][i];
        }
    }
    for(int i = N; i >= 0; --i) {//往上同时跳
        if(grand[a][i] == grand[b][i]) continue;
        ans += gw[a][i];
        ans += gw[b][i];
        a = grand[a][i];
        b = grand[b][i];
    }
    if(a != b) ans += gw[a][0] + gw[b][0];
    return ans;
}

int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        scanf("%d %d", &n, &m);
        for(int i = 1; i < n; ++i) {
            int x, y, w;
            scanf("%d %d %d", &x, &y, &w);
            e.to = y, e.cos = w;
            G[x].push_back(e);
            e.to = x;
            G[y].push_back(e);
        }
        init();
        for(int i = 1; i <= m; ++i) {
            int x, y;
            scanf("%d %d", &x, &y);
            printf("%d\n", lca(x, y));
        }
    }
    return 0;
}