PAT 甲级 1003. Emergency 使用 优先队列 dijkstra 算法

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 

这一题是最短路径的变形求最短路径的条数，和走最短路径情况下拯救队的最大值，用dijkstra 算法，用 优先队列 priority_queue 可以更快的写出来。最短路径算法主要就是：

1. 用一个数组minl[k]来存到从x点出发到k点的最短路径，比如从1点到1点的最短路径是0 ，所以minl[1]=0, 1到2的最短路径是10，则minl[k]=10 ，如果更新了当前k点路径的话就添加到优先队列中。
2. 接着从minl[]数组中没有被访问过的点中，取路径最小的点再去走一遍，所以就要用到一个上面中以路径小优先的队列来维护，就不用自撸一段代码去求当前minl[]中最小值是哪一个。
3. 
   

#include <iostream>
#include "cstring"
#include <stdio.h>
#include "iomanip"
#include "vector"
#include "cmath"
#include "stack"
#include "algorithm"
#include <math.h>
#include "map"
#include "queue"
using namespace std;
struct node{
 int l,v ;//l是到底v点的距离,v是当前点
 node(){};
 node(int a,int b){l=a;v=b;};
 bool operator <(const node &qq)const//重载<   这个重载可以保证按照l，小的在前，大的在后
 {
     return l>qq.l;
 }
 };

int main()
{
 
    priority_queue <node> q;
    int vist[500]={0};
    int minl[500];
    memset(minl,0x3f,sizeof(minl));
    int minr[500]={0};
    int i,num,s,roads,e,start,r[500],maxr[500]={0};
    cin>>num>> roads>>s>>e;
    start=s;
    for( i=0;i<num;i++)
    {
         cin>>r[i];
    }
    int Map[500][500]={0};
    for(i=0;i<500;i++)
        for(int j=0;j<500;j++)
        Map[i][j]=-1;
    int a,b;
    for(i=0;i<roads;i++)
    {
        cin>>a>>b;
        cin>>Map[a][b];
        Map[b][a]=Map[a][b];
    }
    node t;
    t=node(0,s);
    q.push(t);
    minl[s]=0;
    int len;
    minr[s]=1;
    maxr[s]=r[s];
    while(!q.empty())//dijkstra 算法
    {
        t=q.top();
        q.pop();
        len=t.l;
        s=t.v;
        vist[s]=1;
//    if(s==e)
//        break;
        for(i=0;i<num;i++)
        {


            if(!vist[i]&&Map[s][i]!=-1)
            {
                if(minl[i]>len+Map[s][i])
                {
                     minr[i]=minr[s];// 最小路径条数
                     maxr[i]=max(maxr[i],maxr[s]+r[i]);//拯救队的最大值
                     minl[i]=min(minl[i],len+Map[s][i]);//最短路径数组
                     t=node(minl[i],i );
                    q.push(t);

                }

                else if(minl[i]==len+Map[s][i])
                 {
                     minr[i]+=minr[s];
                     maxr[i]=max(maxr[i],maxr[s]+r[i]);
                 }


            }
        }
    }

// for(i=0;i<num;i++)
//    cout<<minl[i]<<" ";
//    cout<<endl;
//
// for(i=0;i<num;i++)
//    cout<<minr[i]<<" ";
//    cout<<endl;
// for(i=0;i<num;i++)
//    cout<<maxr[i]<<" ";
//    cout<<endl;

cout<<minr[e]<<" "<<maxr[e]<<endl;
 return  0;


}