L2-001 紧急救援

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式:

输入第一行给出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

       代码长度限制      16 KB    时间限制    200 ms    内存限制     64 MB

思路：对于这个题我们肯定不能用仅仅只用dijkstra来求最短路，我们要维护一些额外信息，比如这一个点的前一个点是谁；以当前点结尾的共有多少条长度相同的最短路，不一定召集的数量相同；以每个点结尾的最多召集的人数；还要有一个数组来存下初始时当前节点的人员数量；

需要用到额外数组：

cnt[]        当前点结尾最短路条数

num[]     初始时人员数量

maxnum[]   每个点结尾最多召集的人员数量

---

 求最短路用到的数组：

dist[]    求最短路中的dist数组

st[]    这个数组保证了每个点只会被使用一次

---

最后是这个数据范围，虽然图上没有说边一共有多少，由于我们使用的是邻接表，所以边的个数最大有    ，最好开大点，不然最后一个点会段错误

代码如下:

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

using namespace std;

const int N = 250000;

int h[N], e[N], ne[N], w[N], idx;
int dist[N], num[N], maxnum[N], pre[N], cnt[N];
bool st[N];
int n, m, bg, ed;

void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++;
}

void dijkstra(int start)
{
    memset(dist, 0x3f, sizeof dist);
    
    //初始化操作
    dist[start] = 0;
    maxnum[start] = num[start];
    pre[start] = -1;
    cnt[start] = 1;
    
    for(int cx = 0; cx < n; cx ++)
    {
        int t = -1;
        for(int j = 0; j < n; j ++)
        {
            if(!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
            
        }
            st[t] = true;
            
            for(int i = h[t]; i != -1; i = ne[i])
            {
                int j = e[i];
                int distance = w[i];
                if(dist[j] == dist[t] + distance)
                {
                    cnt[j] += cnt[t];
                    if(maxnum[j] < maxnum[t] + num[j])
                    {
                        maxnum[j] = maxnum[t] + num[j];
                        pre[j] = t;
                    }
                }
                else if(dist[j] > dist[t] + distance)
                {
                    dist[j] = dist[t] + distance;
                    cnt[j] = cnt[t];
                    maxnum[j] = maxnum[t] + num[j];
                    pre[j] = t;
                }
            }
    }
}

int main()
{
    memset(h, -1, sizeof h);
    cin >> n >> m >> bg >> ed;
    for(int i = 0; i < n; i ++) cin >> num[i];
    while(m --)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }
    
    dijkstra(bg);
    
    int x = ed;
    vector<int> res;
    res.push_back(x);
    while(pre[x] != -1)
    {
        res.push_back(pre[x]);
        x = pre[x];
    }
    cout << cnt[ed] << " " << maxnum[ed] << endl;
    for(int i = res.size() - 1; i >= 0; i --)
    {
        if(i == res.size() - 1) cout << res[i];
        else cout << " " << res[i];
    }
    return 0;
}

加油eric,坚持下去， 相信自己！