2022年第十三届蓝桥杯大赛软件类决赛C/C++大学B组E题出差

最新推荐文章于 2024-10-12 07:46:51 发布

原创最新推荐文章于 2024-10-12 07:46:51 发布 · 696 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #蓝桥杯

图论专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一种使用Dijkstra算法求解特殊条件下的最短路径问题的方法，即考虑到城市间的旅行需经过中转及隔离的情况。通过调整标准Dijkstra算法，在每次松弛操作时增加隔离时间来解决这个问题。

题意：

有N个城市，编号1...N，无法从1出发到N，需要通过其他城市中转，并且到达后需隔离，求1到N时间最短的路线。

思路：

最短路变形，求时间最短，使用Dijkstra算法松弛时需加上隔离的时间，注意，到达城市N不用隔离。

代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

const int N = 1010;
const int INF = 0x3f3f3f3f;
int n, m, t[N], d[N];
bool vis[N];
struct Edge {
    int u, v, w;
    Edge(int u, int v, int w): u(u), v(v), w(w) {}
};
struct Node {
    int u, d;
    bool operator < (const Node& a) const {
        return d > a.d;
    }
    Node(int u, int d): u(u), d(d) {}
};
vector<Edge> edges;
vector<int> G[N];
int dijkstra() {
    priority_queue<Node> q;
    q.push(Node(1, 0));
    memset(d, INF, sizeof(d));
    memset(vis, 0, sizeof(vis));
    d[1] = 0;
    while(!q.empty()) {
        Node x = q.top(); q.pop();
        if(vis[n])
            break;
        if(vis[x.u])
            continue;
        vis[x.u] = true;
        for(int i=0; i<G[x.u].size(); i++) {
            auto& e = edges[G[x.u][i]];
            if(e.v == n) {
                if(d[x.u] + e.w < d[e.v]) {//到达城市N不需隔离，也可输出时直接减去隔离时间
                    d[e.v] = d[x.u] + e.w;
                    q.push(Node(e.v, d[e.v]));
                }

            }
            else {
                if(d[x.u] + e.w + t[e.v] < d[e.v]) {
                    d[e.v] = d[x.u] + e.w + t[e.v];
                    q.push(Node(e.v, d[e.v]));
                }
            }
        }
    }
    return d[n];
}

int main() {
    cin>>n>>m;
    for(int i=1; i<=n; i++)
        cin>>t[i];
    int u, v, w;
    for(int i=0; i<m; i++) {
        cin>>u>>v>>w;
        edges.push_back(Edge(u, v, w));
        edges.push_back(Edge(v, u, w));//双向路线
        G[u].push_back(i*2);
        G[v].push_back(i*2+1);
    }
    int ans = dijkstra();
    cout<<ans<<endl;
}