hdu 2586 How far away ？ (LCA)

How far away ？

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

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

 

Recommend

lcy   |   We have carefully selected several similar problems for you:  3486 2874 2888 3234 2818 

 

 参考： http://www.cnblogs.com/ylfdrib/archive/2010/11/03/1867901.html

这篇博客写的非常不错，我就是看这个学会的。

第一次写最近公共祖先问题，用的邻接表指针。

对于一棵有根树，就会有父亲结点，祖先结点，当然最近公共祖先就是这两个点所有的祖先结点中深度最大的一个结点。

       0

       |

       1

     /  

   2      3

比如说在这里，如果0为根的话，那么1是2和3的父亲结点，0是1的父亲结点，0和1都是2和3的公共祖先结点，但是1才是最近的公共祖先结点，或者说1是2和3的所有祖先结点中距离根结点最远的祖先结点。

在求解最近公共祖先为问题上，用到的是Tarjan的思想，从根结点开始形成一棵深搜树，非常好的处理技巧就是在回溯到结点u的时候，u的子树已经遍历，这时候才把u结点放入合并集合中，这样u结点和所有u的子树中的结点的最近公共祖先就是u了，u和还未遍历的所有u的兄弟结点及子树中的最近公共祖先就是u的父亲结点。以此类推。。这样我们在对树深度遍历的时候就很自然的将树中的结点分成若干的集合，两个集合中的所属不同集合的任意一对顶点的公共祖先都是相同的，也就是说这两个集合的最近公共最先只有一个。对于每个集合而言可以用并查集来优化，时间复杂度就大大降低了，为O(n + q)，n为总结点数，q为询问结点对数。

算法名称	针对问题	时间消耗	空间消耗
ST算法	一般RMQ问题	O(Nlog2N)-O(1)	O(Nlog2N)
Tarjan算法	LCA问题	O(Na(N) + Q)	O(N)
±1RMQ算法	±1RMQ问题	O(N)-O(1)	O(N)

不懂算法的可以找棵树模拟一下递归的过程。

给出Tarjan离线算法的做法：

//62MS    4232K    1750 B    G++
/*

    第一题LCA：
        在看完算法后发现还未能完全实现，因为理解还不透彻，所以想先做
    一题然后再从题入手。看了别人的结题报告后才写的，感觉还好。
    这一题就是模板题了。这里采用的是离线算法Tarjan。 
     
     树两点的间的最近距离=根节点分别到两点间的最近距离-2*根节点到两点的LCA距离。 
         
         ans = dis[u] + dis[v] - 2 * dis[lca(v, v)] 

*/
#include<iostream>
#include<queue>
#include<vector>
#define N 40005
using namespace std;
struct node{
    int v;
    int d;
    node(int a,int b){
        v=a;d=b;
    }
};
vector<node>child[N],V[N]; //分别记录树和询问的邻接表 
int set[N]; 
int vis[N];
int dis[N];
int res[205][3]; //res[i][0]=u;res[i][1]=v;res[i][2]=LCA(u,v); 
int n;
void init()
{
    for(int i=0;i<=n;i++){ 
        child[i].clear();
        V[i].clear();
    }
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    memset(res,0,sizeof(res));
}
int find(int x)
{
    if(set[x]!=x) set[x]=find(set[x]);
    return set[x];
}
void merge(int x,int y)
{
    int x0=find(x);
    int y0=find(y);
    set[y0]=x0;
} 
void LCA(int u) //tarjan算法 
{
    set[u]=u;
    vis[u]=true;
    for(int i=0;i<V[u].size();i++){
        if(vis[V[u][i].v]){
            res[V[u][i].d][2]=find(V[u][i].v);
        }
    }
    for(int i=0;i<child[u].size();i++){
        if(!vis[child[u][i].v]){
            dis[child[u][i].v]=dis[u]+child[u][i].d;
            LCA(child[u][i].v);
            merge(u,child[u][i].v);
            set[child[u][i].v]=u;
        }
    }
}
int main(void)
{
    int t,m;
    int a,b,d;
    scanf("%d",&t);
    while(t--)
    {
        init();
        scanf("%d%d",&n,&m);
        for(int i=1;i<n;i++){
            scanf("%d%d%d",&a,&b,&d);
            child[a].push_back(node(b,d));
            child[b].push_back(node(a,d)); 
        }
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            V[a].push_back(node(b,i));
            V[b].push_back(node(a,i));
            res[i][0]=a;
            res[i][1]=b;
        }
        LCA(1);
        for(int i=1;i<=m;i++){
            printf("%d
",dis[res[i][0]]+dis[res[i][1]]-2*dis[res[i][2]]);
        }
    }
    return 0;
}

 再给出基于RMQ在线算法的做法：

//78MS    13100K    1892 B    G++
#include<stdio.h>
#include<string.h>
#include<math.h>
#define N 40005
struct node{
    int u,v,d;
    int next;
}edge[2*N]; //邻接表 
int tot,head[N]; //记录先序遍历出现次序，邻接表头 
int set[2*N],first[N]; //记录父节点与次序数 
int dep[2*N],dis[N];  //记录深度和距离 
int dp[2*N][30];
bool vis[N];
void addedge(int u,int v,int d,int &k) //加边 
{
    edge[k].u=u;
    edge[k].v=v;
    edge[k].d=d;
    edge[k].next=head[u];
    head[u]=k++;
}
int Min(int a,int b) //比较的是深度 
{
    return dep[a]<dep[b]?a:b;
}
void dfs(int u,int deep) //dfs将LCA向RMQ转换 
{
     vis[u]=true;
     set[++tot]=u;
     first[u]=tot;
     dep[tot]=deep;
     for(int i=head[u];i!=-1;i=edge[i].next){
         if(vis[edge[i].v]) continue;
         int v=edge[i].v,d=edge[i].d;
         dis[v]=dis[u]+d;
         dfs(v,deep+1);
         set[++tot]=u;
         dep[tot]=deep;
     }
}
int init(int len)
{
    int m=(int)(log(len*1.0)/log(2.0));
    for(int i=1;i<=len;i++)
        dp[i][0]=i;
    for(int j=1;j<=m;j++)
        for(int i=1;i+(1<<j)-1<=len;i++)
            dp[i][j]=Min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
} 
int RMQ(int l,int r)
{
    int m=(int)(log((r-l+1)*1.0)/log(2.0));
    return Min(dp[l][m],dp[r-(1<<m)+1][m]);
}
int LCA(int u,int v)
{
    int x=first[u];
    int y=first[v];
    if(x>y){
        int temp=x;x=y;y=temp;
    }
    return set[RMQ(x,y)];
}
int main(void)
{
    int t,n,q;
    scanf("%d",&t);
    while(t--)
    {
        int u,v,d;
        int num=0;
        scanf("%d%d",&n,&q);
        memset(head,-1,sizeof(head));
        memset(vis,false,sizeof(vis));
        for(int i=1;i<n;i++){
            scanf("%d%d%d",&u,&v,&d);
            addedge(u,v,d,num);
            addedge(v,u,d,num);
        }
        tot=0;
        dis[1]=0;
        dfs(1,1);
        init(2*n-1);
        while(q--){
            scanf("%d%d",&u,&v);
            printf("%d
",dis[u]+dis[v]-2*dis[LCA(u,v)]);
        }
        
    }
    return 0;
}