【天梯赛】L2-001. 紧急救援（dijkstra算法找最短路和最短路径数 + 输出路径）

时间限制
200 ms
内存限制
65536 kB
代码长度限制
8000 B
判题程序
Standard
作者
陈越
作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式：

输入第一行给出4个正整数N、M、S、D，其中N（2<=N<=500）是城市的个数，顺便假设城市的编号为0~(N-1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式：

第一行输出不同的最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出首尾不能有多余空格。

输入样例：
4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2
输出样例：
2 60
0 1 3

分析：
很容易看出来这是单源（起点和终点都是固定的）最短路问题，可以采用dijkstra算法
但是本题中要求的比较多，最短路径（边权和最小）条数，召集的最多的救援队数量（点权和最大），并且要输出相应的路径

可以用优先队列
如果起点到某点的距离不等时，将距离小的放在队头，否则把救援队数量多的放在队头， 具体见代码注释。
在松弛操作中， 比普通的最短路多了记录路径path数组， 最后利用栈输出

#include <bits/stdc++.h>
using namespace std;

#define mem(a,n) memset(a,n,sizeof(a))
#define memc(a,b) memcpy(a,b,sizeof(b))
#define rep(i,a,n) for(int i=a;i<n;i++) ///[a,n)
#define pb push_back
#define IO ios::sync_with_stdio(false)
#define fre freopen("in.txt","r",stdin)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef long long ll;
typedef unsigned long long ull;
const double PI=acos(-1.0);
const double E=2.718281828459045;
const double eps=1e-8;
const int INF=0x3f3f3f3f;
const int MOD=1e8+7;
const int N=5e2+5;
const ll maxn=1e6+5;
const int dir[4][2]= {-1,0,1,0,0,-1,0,1};
const ll inf=0x3f3f3f3f3f3f3f3f;

int n,m,s,d;
int path[N];///记录最短路径
int dis[N];///记录起点到各个点的最短路径距离
int teamnum[N];///记录起点到各个点能召集的救援队数量
bool vis[N];
int w[N],routenum[N];
struct Edge
{
    int v,w;
    Edge() {}
    Edge(int __v,int __w):v(__v),w(__w) {}
};
vector<Edge>g[N];
struct Node
{
    int u;///表示城市编号
    int dis;///表示路径长度
    int team_num;///表示救援队数量
    Node() {}
    Node(int __u,int __dis,int __team_num):u(__u),dis(__dis),team_num(__team_num) {}
    bool operator < (const Node& m)const
    {
        if(dis!=m.dis) return dis>m.dis;///dis小的排在队首 ，因为优先队列默认情况是大顶堆
        return team_num<m.team_num;///team_num大的排在队首
    }
};
void dijkstra(int u)
{
    rep(i,0,n)
    {
        vis[i]=0,dis[i]=INF;
        teamnum[i]=-INF;
        routenum[i]=0;
    }
    priority_queue<Node>pq;
    path[u]=-1,routenum[u]=1;
    dis[u]=0,teamnum[u]=w[u];
    pq.push({u,dis[u],teamnum[u]});
    while(!pq.empty())
    {
        Node now=pq.top();
        pq.pop();
        int u=now.u;
        if(vis[u]) continue;
        vis[u]=1;
        for(auto e: g[u])
        {
            if(dis[e.v]==dis[u]+e.w) routenum[e.v]+=routenum[u];
            if(dis[e.v]>dis[u]+e.w) routenum[e.v]=routenum[u];
            if(dis[e.v]>dis[u]+e.w||(dis[e.v]==dis[u]+e.w&&teamnum[e.v]<teamnum[u]+w[e.v]))
            {
                dis[e.v]=dis[u]+e.w;
                teamnum[e.v]=teamnum[u]+w[e.v];
                pq.push({e.v,dis[e.v],teamnum[e.v]});
                path[e.v]=u;
                //printf("v=%d  dis=%d\n",e.v,dis[e.v]);
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d%d%d",&n,&m,&s,&d))
    {
        rep(i,0,n) scanf("%d",&w[i]);
        rep(i,0,m)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            g[u].pb({v,w});
            g[v].pb({u,w});
        }
        dijkstra(s);
        printf("%d %d\n",routenum[d],teamnum[d]);
        stack<int>st;
        st.push(d);
        int now=d;
        while(~path[now])
        {
            now=path[now];
            st.push(now);
        }
        while(!st.empty())
        {
            if(st.size()>1) printf("%d ",st.top());
            else printf("%d\n",st.top());
            st.pop();
        }
    }
    return 0;
}