1003 Emergency

题目来源：PAT (Advanced Level) Practice

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 C​2​​.

Output Specification:

For each test case, print in one line two numbers: the number of different shortest paths between C​1​​ and C​2​​, 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

words：

emergency 紧急，突发        rescue 营救        scattered 分散的   

题意：

给定一个n个顶点m条边的带权无向图和每个顶点的权值，求从起始点c1到目的点c2的最短路径的条数和最短路径上的最大点权值和；

思路：

1. 使用邻接矩阵存储带权无向图；

2. 当目的点就是起始点时，即c1==c2，路径数为1，点权值和为c1或c2的点权值；否则使用迪杰斯特拉算法求最短路径；

3. 在迪杰斯特拉算法中，除了求最短路劲外，需要使用gather[]数组统计当前点到源点的路径上的点的权值和 ,（初始化为每个点的权值），rout[]数组统计当前点到源点的最短路径数;

//PAT ad 1003 Emergency
#include <iostream>
using namespace std;
#define N 505
#define maxInt 999999999

int n,m,c1,c2;
int adj[N][N];	//邻接矩阵 
int nums[N];	//点权值 

int dis[N];		//最短路径 
bool vis[N];	//访问标记 
int path[N];	//记录前驱 
int gather[N];	//统计当前点到源点的路径上的点的权值和 
int rout[N];	//统计前点到源点的最短路径数

int Dijkstra(int v0)
{
	int i,v,w;

	for(v=0;v<n;v++)
	{
		vis[v]=false;
		dis[v]=adj[v][v0];
        gather[v]=nums[v];
		if(dis[v]<maxInt)
		{
			path[v]=v0;				//定前驱 
			gather[v]+=nums[v0];    //统计路径上点的权值和 
			rout[v]=1;		//统计最短路径数 
		}		
		else
		{
			path[v]=-1;
			rout[v]=0;
		}
			
	}
	vis[v]=true;dis[v0]=0;
	for(i=0;i<n-1;i++)
	{
		int mi=maxInt;
		for(w=0;w<n;w++)
			if(!vis[w]&&dis[w]<mi)	//找最小 
			{
				v=w;mi=dis[w];
			}
		vis[v]=true;
		for(w=0;w<n;w++) 					//做更新 
			if(!vis[w]&&dis[v]+adj[v][w]<dis[w])	//间接距离小于直接距离 
			{
				dis[w]=dis[v]+adj[v][w];
				path[w]=v;
				gather[w]=gather[v]+nums[w];	//点权值和更新 
				rout[w]=rout[v];				//最短路径数更新 
			}
			else if(!vis[w]&&dis[v]+adj[v][w]==dis[w])	//间接距离等于直接距离 
			{
				if(gather[w]<gather[v]+nums[w])		//间接权值和大于直接权值和 
				{
					gather[w]=gather[v]+nums[w];	//点权值和更新
					path[w]=v;
				}
				rout[w]+=rout[v];					//路径数等于两种路径和（直达、间达） 
			}						
	}
}


int main()
{
	cin>>n>>m>>c1>>c2;
	int i,j;
	
	for(i=0;i<n;i++)
		cin>>nums[i];
		
	for(i=0;i<n;i++)		//初始化邻接矩阵 
		for(j=i;j<n;j++)
			adj[i][j]=adj[j][i]=maxInt;
	int a,b,w;		
	for(i=0;i<m;i++)		//输入边和权值 
	{
		cin>>a>>b>>w;
		adj[a][b]=adj[b][a]=w;
	}
	if(c1==c2)							//起始点就是目的点 
        cout<<1<<" "<<nums[c1]<<endl;
    else
    {
        Dijkstra(c1);
        cout<<rout[c2]<<" "<<gather[c2]<<endl;
    }
        
		
	return 0;
}