Come Back Quickly-CSDN博客

该博客介绍了如何利用堆优化的Dijkstra算法来为图中的每个节点寻找最短回路，时间复杂度为O(N*N*logM)。博主详细解释了算法的实现过程，包括初始化距离、使用小根堆以及处理单向边等关键步骤，并提供了一个C++代码示例来演示多源最短路径的计算方法。

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

Come Back Quickly
用堆优化的dijkstra为每个点求得最短回路可过（时间复杂度O(N * N * logM)）
dijkstra算法中将与起点相连的点入小根堆，同时将这些相邻点的距离了初始化，起点的距离仍为∞（注意连个点之间可能有多条边，因此距离每次都要取min）,之后相当于求多源最短路，起点第一次出队时返回（第一次入队时不一定是最小值）。
另外注意点之间是单向边

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <unordered_map>

using namespace std;

const int N = 2010, M = 2010, INF = 0x3f3f3f3f;

typedef pair<int, int> PII;

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


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

int dijkstra(int start) {

    priority_queue<PII, vector<PII>, greater<PII>> q;
    memset(dist, 0x3f, sizeof dist);
    memset(st, 0, sizeof st);


    for (int i = h[start]; i != -1; i = ne[i]) {
        int j = e[i];
        dist[j] = min(w[i], dist[j]);
        q.push({dist[j], j});
    }


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

        int dis = t.first, ver = t.second;
        if (ver == start) return dist[ver];
        if (st[ver])  continue;
        st[ver] = 1;
        for (int i = h[ver]; i != -1; i = ne[i]) {
            int j = e[i];
            if (!st [j] && dist[j] > dis + w[i]) {
                dist[j] = dis + w[i];
                q.push({dist[j], j});
            }
        }
    }

    return -1;

}
int main() {
    memset(h, -1, sizeof h);
    memset(d, 0x3f, sizeof d);
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i ++)   {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    for (int i = 1; i <= n; i ++)
        printf("%d\n", dijkstra(i));

    return 0;

}