HDU 2586 How far away ？ LCA离线tarjan思想

How far away ？

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

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
  
  

解题思路：

1，输入的图和查询的点都告诉你了，离线算法就可以做了

2，tarjan经常用于LCA的离线算法，他本来是一个求联通分量的算法

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
const int maxn = 40005 ;
struct Edge {
    int form,to,dist;
};
vector<Edge> edges ;
vector<int>G[maxn] ;
void add_edge(int from,int to,int dist) {
    edges.push_back((Edge){from,to,dist}) ;
    int mm = edges.size() ;
    G[from].push_back(mm-1) ;
}

vector<Edge> edges2 ;
vector<int>G2[maxn] ;
void add_edge2(int from,int to,int dist=0) {
    edges2.push_back((Edge){from,to,dist}) ;
    int mm = edges2.size() ;
    G2[from].push_back(mm-1) ;
}
int f[maxn] ;
bool vis[maxn] ;
int len[maxn] ;
int find(int x){
    return x==f[x]?x:f[x]=find(f[x]);
}
void LCA(int u){
    f[u] = u ;
    vis[u] = true ;
    for(int i=0;i<G[u].size();i++){
        if(!vis[edges[G[u][i]].to]){
            len[edges[G[u][i]].to] = len[u]+edges[G[u][i]].dist;
            LCA(edges[G[u][i]].to) ;
            f[edges[G[u][i]].to] = u ;
        }
    }
    for(int i=0;i<G2[u].size();i++){
        if(vis[edges2[G2[u][i]].to]){///这里给双向边都存了结果，得益于神奇的^1运算
           edges2[G2[u][i]^1].dist = edges2[G2[u][i]].dist = len[edges2[G2[u][i]].to]+len[u]-2*len[find(edges2[G2[u][i]].to)];
        }
    }
}
int main() {
    int t ;
    scanf("%d",&t) ;
    while(t--) {
        memset(G,0,sizeof(G)) ;
        memset(G2,0,sizeof(G2)) ;
        memset(len,0,sizeof(len)) ;
        memset(vis,false,sizeof(vis)) ;
        edges.clear() ;
        edges2.clear() ;

        int n,m;
        scanf("%d%d",&n,&m) ;
        for(int i=0; i<n-1; i++) {
            int u,v,w ;
            scanf("%d%d%d",&u,&v,&w) ;
            add_edge(u,v,w) ;
            add_edge(v,u,w) ;
        }
        for(int i=0; i<m; i++) {
            int u,v ;
            scanf("%d%d",&u,&v) ;
            add_edge2(u,v) ;
            add_edge2(v,u) ;
        }
        LCA(1) ;
        for(int i=0; i<m; i++) {
            printf("%d\n",edges2[2*i].dist) ;
        }
    }
    return 0;
}