PTA1003 Emergency

题目

As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are marked on the map. When there is an emergency call to you from some other city, your job is to lead your men to the place as quickly as possible, and at the mean time, call up as many hands on the way as possible.

Input Specification:
Each input file contains one test case. For each test case, the first line contains 4 positive integers: N (≤500) - the number of cities (and the cities are numbered from 0 to N−1), M - the number of roads, C​1 and C​2- the cities that you are currently in and that you must save, respectively. The next line contains N integers, where the i-th integer is the number of rescue teams in the i-th city. Then M lines follow, each describes a road with three integers c​1​​ , c​2 and L, which are the pair of cities connected by a road and the length of that road, respectively. It is guaranteed that there exists at least one path from C​1 to C2.

Output Specification:
For each test case, print in one line two numbers: the number of different shortest paths between C1 and C2, and the maximum amount of rescue teams you can possibly gather. All the numbers in a line must be separated by exactly one space, and there is no extra space allowed at the end of a line.
Sample Input:
5 6 0 2
1 2 1 5 3
0 1 1
0 2 2
0 3 1
1 2 1
2 4 1
3 4 1
Sample Output:
2 4

解题关键

这是一条典型的dijkstra单源最短路径问题，有一个小坑：
代码注释中的①②处，即更新最短路径数量时，必须考虑到达路径上的每一个结点都可能有多条最短路径

• ①找到更短路径：City[C1]……City[Next]->City[i]，应该将到City[i]的最短路径数更新为到City[Next]的最短路径数。
• ②相同长度的最短路径：City[C1]……City[Next]->City[i]或原路径City[C1]……City[i]，因此应该将City[i]的最短路径数更新为两条路径的最短路径数之和。

代码

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();	//城市数
		int M = in.nextInt();	//路数
		int C1 = in.nextInt();	//我在的城市
		int C2 = in.nextInt();	//目的城市
		int[] teams = new int[N];	//每个城市的救援队数
		int[][] roads = new int[N][N];	//邻接矩阵，值为两城市间的路长
		int[] distance = new int[N];	//C1到每个城市的最短路径
		int[] teamNum = new int[N];		//C1到每个城市能聚集到的最多救援队数
		int[] shortestNum = new int[N];		//C1到每个城市的最短路径数
		boolean[] visited = new boolean[N];		//记录是否访问
		//初始化teams
		for(int i=0; i<N; i++){
			teams[i] = in.nextInt();
		}
		//初始化邻接表
		for(int i=0; i<N; i++){
			for(int j=0; j<N; j++){
				roads[i][j] = Integer.MAX_VALUE;	//初始化
			}
			roads[i][i] = 0;
		}
		//初始化路径
		for(int i=0; i<M; i++){
			int ii = in.nextInt();
			int jj = in.nextInt();
			int val = in.nextInt();
			roads[ii][jj] = val;
			roads[jj][ii] = val;
		}
		//初始化distance、visited、teamNum、shortestNum
		for(int i=0; i<N; i++){
			distance[i] = roads[C1][i];
			teamNum[i] = teams[C1] + teams[i];
			shortestNum[i] = 1;
		}
		visited[C1] = true;
		teamNum[C1] = teams[C1];
		
		//dijkstra
		while(true){
			//寻找下一个未被访问过，且距离最短的城市
			int next = -1, minDistance = Integer.MAX_VALUE;
			for(int i=0; i<N; i++){
				if(!visited[i]&&distance[i]<minDistance){
					next = i;
					minDistance = distance[i];
				}
			}
			//所有城市都访问过了
			if(next==-1) break;
			//找到下一个，遍历每个未访问过的邻接点
			visited[next] = true;
			for(int i=0; i<N; i++){
				if(!visited[i]&&roads[next][i]!=Integer.MAX_VALUE){
					int newDistance = distance[next]+roads[next][i];
					if(newDistance<distance[i]){
						//更新最短路径
						distance[i] = newDistance;
						//更新数量
						teamNum[i] = teamNum[next] + teams[i];
						shortestNum[i] = shortestNum[next];		//①
					}else if(newDistance==distance[i]){
						int newTeamNum = teamNum[next] + teams[i];
						if(newTeamNum>teamNum[i]){
							//更新最多救援队数
							teamNum[i] = newTeamNum;
						}
						//更新最短路径数
						shortestNum[i] = shortestNum[next] + shortestNum[i];		//②
					}
				}
				
			}
		}
		System.out.println(String.valueOf(shortestNum[C2])+' '+String.valueOf(teamNum[C2]));
	}

}