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+;
 typedef long long type_weight;
 struct Edge
 {
     //根据题意定义weight的类型
     //可能为long long 型,也可能为int型
     //用typedef定义type_weight,方便修改类型
     int vex;
     type_weight weight;
     Edge(int v=,type_weight w=):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,,sizeof(visited));
     //初始化dist[]为LINF,即长整型的最大值(无穷大)
     for(int i=;i<=n;i++)
         dist[i]=LINF;
     dist[start]=;
     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=;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=;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=;i<=Q;i++)
     {
         int x,y;
         scanf("%d%d",&x,&y);
         printf("%lld\n",dist[x]+dist[y]);
     }
     return ;
 }