L2-001 紧急救援 (25 分)

最新推荐文章于 2024-07-23 11:56:21 发布

tcy今天长胖了吗

最新推荐文章于 2024-07-23 11:56:21 发布

阅读量140

点赞数

分类专栏： CCCC 文章标签：图论 dijkstra

本文链接：https://blog.csdn.net/qq_49451105/article/details/113795495

版权

CCCC 专栏收录该内容

109 篇文章 3 订阅

订阅专栏

L2-001 紧急救援 (25 分)

题目

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

输入格式:

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

思路

dijtra + 路径还原的变形，模板可以参考挑程的。这里的变形在于可能有多条最短路，我们要选取其中救援队数量最多的路径，因此要额外统计从起点到每个点的最多救援队数量，即在边权的基础上又多一个需要考虑的权值。

在最短路计算时我们用dis数组存储从起点到该点的最短路径长度，用disnum数组存储从起点到该点有几条最短路；路径还原时我们用pre数组来表示上一个点的信息，并用teamnum数组统计从起点到该点的最大救援队数量。每次松弛时，都对以上数组进行更新。最终输出disnum[D] 、teamnum[D] 和pre数组的逆向路径还原即可。（路径还原这部分如果不明白建议直接看挑程）

代码中我标注出了我卡题过程中出错了的地方，希望能给出一些参考。

这题卡了有点久，今天下午无所事事就看看代码，看着看着看到了自己出错的位置。新年过题，开心！

代码

#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define PI acos(-1)
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int N = 1e4 + 19;
const ll mod = 1e9 + 7;

struct node
{
    int v, dist;
    node(){}
    node(int vv, int dd){v = vv; dist = dd;}
    bool operator < (const node& a) const
    {
        if(dist == a.dist)
        {
            return v < a.v;
        }
        return dist > a.dist;
    }
};

vector<node> vec[N];
int dis[N];
int num[N];
int teamnum[N];
int disnum[N];
int pre[N];
int n, m, s, d;

void dij(int s)
{
    fill(dis, dis + n + 1, INF);
    fill(pre, pre + n + 1, INF);
    dis[s] = 0;
    disnum[s] = 1;
    for(int i = 0; i < vec[s].size(); i++)
    {
        disnum[vec[s][i].v] = 1;
    }
    teamnum[s] = num[s];
    priority_queue<node> que;
    que.push(node(s, 0));
    while(!que.empty())
    {
        node x = que.top();
        que.pop();
        for(int i = 0; i < vec[x.v].size(); i++)
        {
            node y = vec[x.v][i];
            if(dis[y.v] > x.dist + y.dist)
            {
                dis[y.v] = x.dist + y.dist;
                pre[y.v] = x.v;
                teamnum[y.v] = teamnum[x.v] + num[y.v];
                disnum[y.v] = disnum[x.v];
                que.push(node(y.v, dis[y.v]));
            }
            else if(dis[y.v] == x.dist + y.dist)
            {
                if(teamnum[y.v] < teamnum[x.v] + num[y.v])//我最后就是这里的判断条件定错了（定成了num[y.v]）
                {
                    pre[y.v] = x.v;
                    teamnum[y.v] = teamnum[x.v] + num[y.v];
                }
                disnum[y.v] += disnum[x.v];//这里也是一个易错点，不是简单的+1
            }
        }
    }
}

int main()
{
    cin >> n >> m >> s >> d;
    for(int i = 0; i < n; i++)
    {
        cin >> num[i];
    }
    for(int i = 0; i < m; i++)
    {
        int u, v, dist;
        cin >> u >> v >> dist;
        vec[u].push_back(node(v, dist));
        vec[v].push_back(node(u, dist));
    }
    dij(s);
    stack<int> st;//用栈实现逆向还原
    int tmp = d;
    while(pre[tmp] != INF){
        st.push(tmp);
        tmp = pre[tmp];
    }
    st.push(s);
    cout << disnum[d] << ' ' << teamnum[d] << endl;
    while(!st.empty())
    {
        cout << st.top();
        st.pop();
        if(st.size())
        {
            cout << ' ';
        }
    }
    cout << endl;
    return 0;
}