HDU ~ 2544 ~ 最短路（Dijkstra模板，常规版 and 优先队列优化版）

最新推荐文章于 2021-04-10 00:35:05 发布

张松超

最新推荐文章于 2021-04-10 00:35:05 发布

阅读量446

点赞数

CC 4.0 BY-SA版权

分类专栏：【最短路/差分约束】【模板】

本文链接：https://blog.youkuaiyun.com/ZscDst/article/details/79185474

【最短路/差分约束】同时被 2 个专栏收录

40 篇文章

订阅专栏

【模板】

23 篇文章

订阅专栏

本文详细介绍Dijkstra算法的原理及其实现方式，包括使用优先队列优化的版本，并提供完整的C++代码实现。通过实例演示了如何求解两点间的最短路径。

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

Dijkstra:

复杂度：,优先队列优化。

优点：稳定。

缺点：不能有负权。

优先队列:

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int from, to, dist;
    Edge() {}
    Edge(int u, int v, int d) : from(u), to(v), dist(d) {}
};
struct Dijkstra
{
    int n, m;            // 点数和边数
    vector<Edge> edges;  // 边列表
    vector<int> G[MAXN]; // 每个节点出发的边编号（从0开始编号）
    bool done[MAXN];     // 是否已永久标号
    int d[MAXN];         // s到各点的距离
    int p[MAXN];         // p[i]表示最短路径树中到达i点的边的编号
    void init(int n)
    {
        this->n = n, m = 0;
        edges.clear();                            // 清空边表
        for (int i = 0; i <= n; i++) G[i].clear(); // 清空邻接表
    }
    void AddEdge(int from, int to, int dist)
    { // 如果是无向图，每条无向边需调用两次AddEdge
        edges.emplace_back(from, to, dist);
        m = edges.size();
        G[from].push_back(m - 1);
    }
    struct HeapNode
    {
        int d, u;
        bool operator < (const HeapNode& rhs) const
        {
            return d > rhs.d;
        }
    };
    void dijkstra(int s)
    {
        priority_queue<HeapNode> q;
        for (int i = 0; i <= n; i++) d[i] = INF;
        d[s] = 0;
        memset(done, 0, sizeof(done));
        q.push({0, s});
        while (!q.empty())
        {
            HeapNode x = q.top();
            q.pop();
            int u = x.u;
            if (done[u]) continue;
            done[u] = true;
            for (auto& id : G[u])
            {
                Edge& e = edges[id];
                if (d[e.to] > d[u] + e.dist)
                {
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = id;
                    q.push({d[e.to], e.to});
                }
            }
        }
    }
}gao;

int n, m;
int main()
{
    while (~scanf("%d%d", &n, &m) && (n+m))
    {
        gao.init(n);
        while (m--)
        {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            gao.AddEdge(u, v, w);
            gao.AddEdge(v, u, w);
        }
        gao.dijkstra(1);
        printf("%d\n", gao.d[n]);
    }
    return 0;
}
/*
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
*/
//Answer:3 2

常规：

注意编号为从1到N。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int from, to, dist;
    Edge() {}
    Edge(int u, int v, int d) : from(u), to(v), dist(d) {}
};
struct Dijkstra
{
    int n, m;            // 点数和边数
    vector<Edge> edges;  // 边列表
    vector<int> G[MAXN]; // 每个节点出发的边编号（从0开始编号）
    bool done[MAXN];     // 是否已永久标号
    int d[MAXN];         // s到各点的距离
    int p[MAXN];         // p[i]表示最短路径树中到达i点的边的编号
    void init(int n)
    {
        this->n = n, m = 0;
        edges.clear();                            // 清空边表
        for (int i = 0; i <= n; i++) G[i].clear(); // 清空邻接表
    }
    void AddEdge(int from, int to, int dist)
    { // 如果是无向图，每条无向边需调用两次AddEdge
        edges.emplace_back(from, to, dist);
        m = edges.size();
        G[from].push_back(m - 1);
    }
    void dijkstra(int s)
    {
        for (int i = 0; i <= n; i++) d[i] = INF;
        d[s] = 0;
        memset(done, 0, sizeof(done));
        for (int i = 1; i <= n; i++)
        {
            int pos, MIN = INF;
            for (int j = 1; j <= n; j++)
            {
                if(!done[j] && d[j] <= MIN) MIN = d[pos = j];
            }
            done[pos] = true;
            for (auto id : G[pos])
            {
                Edge& e = edges[id];
                if (d[e.to] > d[pos] + e.dist)
                {
                    d[e.to] = d[pos] + e.dist;
                    p[e.to] = id;
                }
            }
        }
    }
}gao;

int n, m;
int main()
{
    while (~scanf("%d%d", &n, &m) && (n+m))
    {
        gao.init(n);
        while (m--)
        {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            gao.AddEdge(u, v, w);
            gao.AddEdge(v, u, w);
        }
        gao.dijkstra(1);
        printf("%d\n", gao.d[n]);
    }
    return 0;
}
/*
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
*/
//Answer:3 2