2018.7中石油个人赛第4场(D-Transit Tree Path)-最短路算法

6690: Transit Tree Path

时间限制: 1 Sec  内存限制: 128 MB
提交: 472  解决: 132
[提交] [状态] [讨论版] [命题人:admin]

题目描述

You are given a tree with N vertices.
Here, a tree is a kind of graph, and more specifically, a connected undirected graph with N−1 edges, where N is the number of its vertices.
The i-th edge (1≤i≤N−1) connects Vertices ai and bi, and has a length of ci.

You are also given Q queries and an integer K. In the j-th query (1≤j≤Q):

find the length of the shortest path from Vertex xj and Vertex yj via Vertex K.
Constraints
3≤N≤10⁵
1≤ai,bi≤N(1≤i≤N−1)
1≤ci≤10⁹(1≤i≤N−1)
The given graph is a tree.
1≤Q≤10⁵
1≤K≤N
1≤xj,yj≤N(1≤j≤Q)
xj≠yj(1≤j≤Q)
xj≠K,yj≠K(1≤j≤Q)

输入

Input is given from Standard Input in the following format:
N  
a1 b1 c1  
:  
a_N−1 b_N−1 c_N−1
Q K
x1 y1
:  
xQ yQ

 

输出

Print the responses to the queries in Q lines.
In the j-th line j(1≤j≤Q), print the response to the j-th query.

样例输入

5
1 2 1
1 3 1
2 4 1
3 5 1
3 1
2 4
2 3
4 5

样例输出

3
2
4

提示

The shortest paths for the three queries are as follows:
Query 1: Vertex 2 → Vertex 1 → Vertex 2 → Vertex 4 : Length 1+1+1=3
Query 2: Vertex 2 → Vertex 1 → Vertex 3 : Length 1+1=2
Query 3: Vertex 4 → Vertex 2 → Vertex 1 → Vertex 3 → Vertex 5 : Length 1+1+1+1=4

/*
题意 : 
    求结点x经过结点k到达结点y的最短距离
    转化为以k结点为起始点,求k分别到结点x和结点y的最短距离
    用到SPFA算法
*/
//赛后补题,一开始将dist[]的值赋值为INF,wa了
//后来想了一下,INF值为1061109567
//虽然大于1e9,但时如果两条边都是1e9,则加和就>INF,此时就会出错
//所以需要用LINF来个dist[]中的数组初始化为无穷大
//一定要判断清除用哪个
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3f
const int maxn=1e5+1;
typedef long long type_weight;
struct Edge
{
    //根据题意定义weight的类型
    //可能为long long 型,也可能为int型
    //用typedef定义type_weight,方便修改类型
    int vex;
    type_weight weight;
    Edge(int v=0,type_weight w=0):vex(v),weight(w){}
};
vector<Edge>E[maxn];

//向E[u]中加入(v,weight) : 边u与边v相连,其权值为weight
void addedge(int u,int v,type_weight weight)
{
    E[u].push_back(Edge(v,weight));
}
//visited[i] : 判断结点i是否在队列中
//dist[] : 存储最短距离,最好定义成long long 型
//cnt[] : 判断是否存在负环
bool visited[maxn];
long long dist[maxn];
int cnt[maxn];
//求从start结点到其他结点的最短距离
//共n个结点
bool SPFA(int start,int n)
{
    memset(visited,0,sizeof(visited));
    //初始化dist[]为LINF,即长整型的最大值(无穷大)
    for(int i=1;i<=n;i++)
        dist[i]=LINF;
    dist[start]=0;
    visited[start]=true;

    queue<int >que;
    while(!que.empty())
        que.pop();
    que.push(start);

    while(!que.empty())
    {
        int u=que.front();
        que.pop();

        //遍历以u为弧尾的所有结点
        //E[u][i].v : 以u为弧尾的结点
        //E[u][i].weight : 结点u与结点E[u][i].v之间的权重
        for(int i=0;i<E[u].size();i++)
        {
            int v=E[u][i].vex;

            //判断边u是否能松弛边v
            if(dist[v] > dist[u]+E[u][i].weight)
            {
                dist[v]=dist[u]+E[u][i].weight;
                if(!visited[v])
                {
                    que.push(v);
                    visited[v]=true;
                    //如果某个结点进入队列的此数超过n-1次,则此图存在负环
                    if(++cnt[v] > n)
                        return false;
                }
            }
        }
    }
    return true;
}

int main()
{
    int N;
    scanf("%d",&N);
    for(int i=1;i<N;i++)
    {
        int a,b;
        type_weight weight;
        scanf("%d%d%lld",&a,&b,&weight);
        addedge(a,b,weight);
        addedge(b,a,weight);
    }
    int Q,K;
    scanf("%d%d",&Q,&K);
    SPFA(K,N);
    for(int i=1;i<=Q;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%lld
",dist[x]+dist[y]);
    }
    return 0;
}