HDU2586 B - How far away ？

How far away ？

problem

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

 

解题思路：

先解读一下题意，先输入n和m，

就是给你n个房间，它们能构成一个无向无环图，然后再给你n-1条边以及他们的权值

然后就是m次询问，每次询问给你两个房间号，让你求他们之间的最短的路径长

 

我在做的时候受到了别人的启发，即：两个点之间的最短路径长就是这两个点到根的路径长的和再减去两倍的他们的LCA到根的长

其实一开始想要建立一个数组w[i][j]来代表i到j的距离，但是发现太麻烦

而用第一个方法则很容易就将所有的点到根节点的路径长给算出来

然后就是继续倍增的LCA板子，求出他们的LCA就行了

 

代码如下：

#include <bits/stdc++.h>
#define N 40050
using namespace std;

int n,m;
struct node
{
    int v,w,next;
}e[2*N];
int tot,head[N];
int father[N<<1][30];
int depth[N<<1];
int weight[N<<1];

int tol;
inline void add(int u,int v,int w)
{
    e[tol].v=v;
    e[tol].w=w;
    e[tol].next=head[u];
    head[u]=tol++;
}

inline void dfs(int now,int fa)
{
    depth[now]=depth[fa]+1;
    father[now][0]=fa;
    for(int i=1;(1<<i)<=depth[now];++i)
        father[now][i]=father[father[now][i-1]][i-1];
    for(int i=head[now];i;i=e[i].next)
    {
        if(e[i].v!=fa) dfs(e[i].v,now);
    }
}

inline int lca(int u,int v)
{
    if(depth[u]<depth[v]) swap(u,v);
    int d=depth[u]-depth[v];
    for(int i=0;i<=20;++i)
        if((1<<i)&d) u=father[u][i];
    if(u==v) return u;
    for(int i=20;i>=0;--i)
    {
        if(depth[father[u][i]]<=0) continue;
        if(father[u][i]!=father[v][i])
        {
            u=father[u][i];
            v=father[v][i];
        }
    }
    return father[u][0];
}

//这个部分就是处理所有点到根节点的距离
//其实是仿照上面倍增处理father数组的方法
bool vis[N<<1];
inline void dealw(int a,int frontw)
{
    vis[a]=true;
    for(int i=head[a];i;i=e[i].next)
    {
        if(!vis[e[i].v])
        {
            weight[e[i].v]=e[i].w+frontw;
            dealw(e[i].v,weight[e[i].v]);
        }
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(depth,0,sizeof(depth));
        memset(father,0,sizeof(father));
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        memset(weight,0,sizeof(weight));
        int x,y,z;
        tol=1;
        scanf("%d%d",&n,&m);
        for(int i=1;i<n;++i)
        {
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            add(y,x,z);
        }
        dfs(1,0);
        dealw(1,0);
        weight[1]=0;
        for(int i=0;i<m;++i)
        {
            cin>>x>>y;
            z=lca(x,y);
            //cout<<z<<endl;
            cout<<weight[x]+weight[y]-2*weight[z]<<endl;
        }
    }
    return 0;
}