How far away ？ HDU - 2586

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.

InputFirst 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.OutputFor 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
题解：倍增法（创造算法的人真的是牛），首先对于任意顶点，利用父亲节点的信息，可以通过Fa2[v]=Fa[Fa[v]]得到向上走两步所到的顶点。
再利用这一信息，又可以通过Fa4[v]=Fa2[Fa2[v]]得到其向上走四步所到的顶点。依次类推，可以得到其向上走 2的k次方 布所到顶点Fa[k][v].

// ConsoleApplication1.cpp: 定义控制台应用程序的入口点。
//

//#include "stdafx.h"
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int max_log = 20;
const int maxn = 40004;

int n, m, tot;
int head[maxn], dp[maxn], Fa[max_log][maxn], sum[maxn];

struct node {
    int to, va, next;
}e[2*maxn];

void Inite() {
    tot = 0;
    memset(sum, 0, sizeof(sum));
    memset(head, -1, sizeof(head));
}

void addedge(int u, int v, int w) {
    e[tot].to = v;
    e[tot].va = w;
    e[tot].next = head[u];
    head[u] = tot++;
}

void DFS(int u, int d, int pa) {
    dp[u] = d;
    Fa[0][u] = pa;
    for (int i = head[u]; i != -1; i = e[i].next) {
        int v = e[i].to;
        if (v == pa) continue;
        sum[v] = sum[u] + e[i].va;
        DFS(v, d + 1, u);
    }
}

void Get_Fa() {
    DFS(1, 0, -1);
    for (int i = 0; i + 1 < max_log; i++) {
        for (int v = 1; v <= n; v++) {
            if (Fa[i][v] < 0) Fa[i + 1][v] = -1;
            else Fa[i + 1][v] = Fa[i][Fa[i][v]];
        }
    }
}

int Lca(int u, int v) {
    if (dp[u] > dp[v]) swap(u, v);
    for (int i = 0; i < max_log; i++) {
        if ((dp[v] - dp[u]) >> i & 1) v = Fa[i][v];
    }
    if (u == v) return u;
    for (int i = max_log; i >= 0; i--) {
        if (Fa[i][u] != Fa[i][v]) {
            u = Fa[i][u];
            v = Fa[i][v];
        }
    }
    return Fa[0][u];
}

int main()
{
    int kase;
    cin >> kase;
    while (kase--) {
        Inite();
        cin >> n >> m;
        for (int i = 2; i <= n; i++) {
            int u, v, w;
            cin >> u >> v >> w;
            addedge(u, v, w);
            addedge(v, u, w);
        }
        Get_Fa();
        for (int i = 1; i <= m; i++) {
            int u, v;
            cin >> u >> v;
            int com_pa= Lca(u, v);
            int ans = sum[u] - sum[com_pa] + sum[v] - sum[com_pa];
            cout << ans << endl;
        }
    }
    return 0;
}