HDOJ 2586 How far away ？ (LCA ST算法)

How far away ？

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 9929    Accepted Submission(s): 3519

Problem Description

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
  
  

 

Source

ECJTU 2009 Spring Contest

 

题解:我们可以把这题转换成LCA来做, 求得两点间的LCA, 然后利用他们分别到root的距离相加, 减去两倍的LCA到root的距离, 就是两个点之间的距离.

#include <cstdio>
#include <cstring>

const int N = 40010;
int head[N];
int dis[N], fp[N], deep[N * 2], vertex[N * 2];
int total;

struct node{
    int v, value, next;
}Node[N * 2];

void add_edge(int u, int v, int value, int num) {
    node tmp = {v, value, head[u]};
    Node[num] = tmp;
    head[u] = num;
}

void Init() {
    memset(head, -1, sizeof(head));
    total = 0;
    dis[1] = 0;
}

void dfs(int pre, int u, int dep) {
    vertex[++total] = u;
    fp[u] = total;
    deep[total] = dep;
    for (int i = head[u]; ~i; i = Node[i].next) {
        int v = Node[i].v;
        if (v != pre) {
            dis[v] = dis[u] + Node[i].value;
            dfs(u, v, dep + 1);
            vertex[++total] = u;
            deep[total] = dep;
        }
    }
}

int dp[N * 2][20];

void ST(int n) {
    for (int i = 1; i <= n; ++i)
        dp[i][0] = i;
    for (int j = 1; j < 20; ++j)
        for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
            int a = dp[i][j - 1], b = dp[i + (1 << (j - 1))][j - 1];
            dp[i][j] = deep[a] < deep[b] ? a : b;
        }
}

int RMQ(int l, int r) {
    int k = 0;
    while (1 << (k + 1) <= (r - l + 1)) ++k;
    int a = dp[l][k], b = dp[r - (1 << k) + 1][k];
    return deep[a] < deep[b] ? a : b;
}

int LCA(int u, int v) {
    u = fp[u], v = fp[v];
    if (u < v) return vertex[RMQ(u, v)];
    return vertex[RMQ(v, u)];
}

int main() {
    int T;
    scanf("%d", &T);

    while (T--) {
        Init();
        int n, m;
        int num = 0;

        scanf("%d%d", &n, &m);

        for (int i = 1; i < n; ++i) {
            int u, v, value;
            scanf("%d%d%d", &u, &v, &value);
            add_edge(u, v, value, num++);
            add_edge(v, u, value, num++);
        }

        dfs(-1, 1, 1);
        ST(total);

        while (m--) {
            int u, v;
            scanf("%d%d", &u, &v);
            int lca = LCA(u, v);
            printf("%d\n", dis[u] + dis[v] - 2 * dis[lca]);
        }
    }

    return 0;
}