【备战蓝桥杯国赛-国赛真题】出差

openallzzz

已于 2023-05-03 21:43:30 修改

阅读量351

点赞数 1

分类专栏：蓝桥杯文章标签：蓝桥杯 c++ 算法

于 2023-05-03 17:31:29 首次发布

本文链接：https://blog.youkuaiyun.com/Zygood_/article/details/130474991

版权

蓝桥杯专栏收录该内容

15 篇文章

订阅专栏

文章讲述了在一道图论问题中，如何使用Dijkstra算法来求解最短路径，同时考虑了节点的隔离时间。作者遇到了在某些测试点超时的问题，通过改为朴素Dijkstra和堆优化Dijkstra两种方法，最终在特定在线评测系统上获得全部通过。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：https://www.dotcpp.com/oj/problem2695.html

在这里插入图片描述

思路

为了方便，在建图的过程中，两个点之间的距离我们需要重新定义，即点x到y的距离再加上在点y需要进行隔离的时间，另外，题目中说明了目标点n的隔离时间不计，需要注意，处理的时候我们将点n的隔离时间标记为0即可。

坑点：本题的代码最开始是使用堆优化版的Dijkstra写的，但是在dotcpp网站上总是有三个点超时，我百思不得其解，后来联系到了网站的管理员，想了解一些这三个测试数据的特点，但是管理员目前还没有回复我关于数据的问题，后来我在蓝桥杯官网上测试了本题的堆优化代码，全部通过（AC），我想着总是有三个点过不去，不大完美，后来增加了朴素版的Dijstra代码，最终在dotcpp上成功全部通过（AC）。

两份代码都会放在下面。

代码（C++）

朴素版Dijkstra（dotcpp上AC）

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int g[N][N];
int dist[N], st[N], v[N];

int dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for(int i = 0; i < n; i ++) {
        int t = -1;
        for(int j = 1; j <= n; j ++) {
            if(!st[j] && (t == -1 || (dist[j] < dist[t]))) {
                t = j;
            }
        }

        if(t == -1) break;
        for(int j = 1; j <= n; j ++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        st[t] = true;
    }

    return dist[n];
}

int main() {
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) cin >> v[i];
    v[n] = 0;

    memset(g, 0x3f, sizeof g);
    while(m --) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = c + v[b];
        g[b][a] = c + v[a];
    }

    cout << dijkstra() << "\n";
    return 0;
}

堆优化版Dijstra（蓝桥杯官网上AC了）

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

using namespace std;

typedef pair<int, int> PII;

const int N = 1010, M = 20010;

int n, m;
int h[N], e[M], ne[M], w[M], idx;
int v[N], dist[N], st[N];

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

int dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});

    while(heap.size()) {
        auto t = heap.top(); heap.pop();

        int node = t.second;

        if(st[node]) continue;
        st[node] = true;

        for(int i = h[node]; i != -1; i = ne[i]) {
            int j = e[i];
            if(dist[j] > dist[node] + w[i]) {
                dist[j] = dist[node] + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    return dist[n];
}

int main() {
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) cin >> v[i];
    v[n] = 0;

    memset(h, -1, sizeof h);
    while(m --) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
        add(b, a, c);
    }

    if(n == 1) {
        cout << 0 << "\n";
        return 0;
    }

    cout << dijkstra() << "\n";
    return 0;
}