PAT A1003

1003 Emergency (25)（25 分）

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

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, C1 and C2 - 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 c1, c2 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 C1 to C2.

Output

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

输入格式：

城市数  路数  所在城市    需救援城市

每个城市救援队伍数目

每条路的起点终点距离

输出格式：

C1、C2间最短路径数目，可以聚集的最大救援队数目。

题目要求：

当有救援请求时，尽可能快地到达地点，召集尽可能多的救援队。

【C++】fill函数，fill与memset函数的区别

• memset函数

  • 按照字节填充某字符
  • 在头文件<cstring>里面

• fill函数

  • 按照单元赋值，将一个区间的元素都赋同一个值
  • 在头文件<algorithm>里面

• 因为memset函数按照字节填充，所以一般memset只能用来填充char型数组，（因为只有char型占一个字节）如果填充int型数组，除了0和-1，其他的不能。因为只有00000000 = 0，-1同理，如果我们把每一位都填充“1”，会导致变成填充入“11111111”

• 而fill函数可以赋值任何，而且使用方法特别简便：

  • fill(arr, arr + n, 要填入的内容);

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>

using namespace std;

const int MAXV=510;
const int INF=1000000000;

//n为顶点数,M为边数,st和ed分别为起点和终点
//G为邻接矩阵,weight为点权
//d[]记录最短距离,w[]记录最大点权之和,num[]记录最短路径条数
int n,m,st,ed,G[MAXV][MAXV],weight[MAXV];
int d[MAXV],w[MAXV],num[MAXV];
bool vis[MAXV]={false};

void Dijkstra(int s){
    fill(d,d+MAXV,INF);
    memset(num,0,sizeof(num));
    memset(w,0,sizeof(w));
    d[s]=0;
    w[s]=weight[s];
    num[s]=1;
    for(int i=0;i<n;i++){
        int u=-1,MIN=INF;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<MIN){//从未访问节点中找到d[]最小的
                u=j;
                MIN=d[j];
            }
        }
        if(u==-1) return;//找不到小于INF的d[]说明剩下定点和s不连通
        vis[u]=true;
        for(int k=0;k<n;k++){
            if(vis[k]==false&&G[u][k]!=INF){
                if(d[u]+G[u][k]<d[k]){
                    d[k]=d[u]+G[u][k];
                    w[k]=w[u]+weight[k];
                    num[k]=num[u];
                }else if(d[u]+G[u][k]==d[k]){
                    if(w[u]+weight[k]>w[k]){
                        w[k]=w[u]+weight[k];
                    }
                    num[k]+=num[u];
                }
            }
        }
    }
}

int main()
{
    scanf("%d%d%d%d",&n,&m,&st,&ed);
    for(int i=0;i<n;i++){
        scanf("%d",&weight[i]);
    }
    int u,v;
    fill(G[0],G[0]+MAXV*MAXV,INF);
    for(int i=0;i<m;i++){
        scanf("%d%d",&u,&v);
        scanf("%d",&G[u][v]);
        G[v][u]=G[u][v];
    }
    Dijkstra(st);
    printf("%d %d\n",num[ed],w[ed]);
    return 0;
}