PAT甲级 1003 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 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

题目大意：
每个城市有不同数量的救援队，城市和城市之间的距离不同，让求出从城市c1到城市c2的最短路径的个数，和所有路径上救援队数量的总和。（就是在Dijkstra算法上做一些修改）

代码如下:

#include <iostream>
using namespace std;
const int inf=99999999;
int main()
{
   int n,m,c1,c2,v1,v2,cost;
    cin>>n>>m>>c1>>c2;
    int a[n];
    for(int i=0;i<n;i++)
        cin>>a[i];
    int edge[520][520];
    fill(edge[0],edge[0]+520*520,inf);
    for(int i=0;i<m;i++){
        cin>>v1>>v2>>cost;
        edge[v2][v1]=edge[v1][v2]=cost;
    }
    int final[520]={0},d[520],w[520]={0},j,min,num[520]={0};
    fill(d,d+520,inf);
    d[c1]=0;w[c1]=a[c1];num[c1]=1;
    while(1){
        min=inf;
        for(int k=0;k<n;k++)
            if(final[k]==0&&d[k]<min){
                    j=k; min=d[k];
            }
        final[j]=1;
        if(j==c2) break;
        for(int k=0;k<n;k++){
            if(final[k]==0&&(d[j]+edge[j][k]<d[k])){
                    d[k]=d[j]+edge[j][k];
                    w[k]=w[j]+a[k];
                    num[k]=num[j];
            }
            else if(d[j]+edge[j][k]==d[k]){
                    num[k]=num[k]+num[j];
                    if(w[j]+a[k]>w[k]) w[k]=w[j]+a[k];
            }
        }
    }
    cout<<num[c2]<<" "<<w[c2]<<endl;
    return 0;
}

来总结一下：
1）比原来的Dijkstra算法增加了两个数组，w[i]用来存储所有到达i这个地方的点权和（也就是救援队的数目），num[i]用来存储，达到i这个地方所有的最短路径的个数。原来的final[i]数组来表示，这个是否加入集合，d[i]则表明，到i地方的最短路径的长度。
2）因为新增加了两个数组，所以一开始不能给起点赋初值，只需要让起点的d[c1]=0，让其在第一次循环中被选出来即可。
3）来说一下fill函数吧（初始化）

• 按照单元赋值，将一个区间的元素都赋同一个值（在头文件algorithm中）
• fill(arr, arr + n, 要填入的内容);（普通数组）
• fill(v.begin(), v.end(), -1);（vector）
• fill(f[0], f[0]+N*N, 要填入的内容); （二维数组）