Dijkstra算法

最新推荐文章于 2025-09-19 14:02:42 发布

原创最新推荐文章于 2025-09-19 14:02:42 发布 · 440 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#图论 #算法 #c++

数据结构&算法专栏收录该内容

31 篇文章

订阅专栏

本文详细介绍了Dijkstra算法的原理及应用，包括朴素版和堆优化版两种实现方式，并提供了C++代码示例。通过对比不同版本的时间复杂度，帮助读者理解算法优劣。

Dijkstra 算法

只适用于正权边

思想是贪心的思想

朴素版Dijkstra 适合稠密图

朴素Dijkstra 思路

集合S为已经确定最短路径的点集。

初始化距离： 1 号结点的距离为零，其他结点的距离设为无穷大（看具体的题）。
循环 n 次，每一次将集合 S 之外距离最短 X 的点加入到 S 中去（这里的距离最短指的是距离 1 号点最近。点 X 的路径一定最短，基于贪心，严格证明待看）。然后用点 X 更新 X 邻接点的距离。

时间复杂度分析

寻找路径最短的点：O(n^2)O(n2)

加入集合S：O(n)O(n)

更新距离：O(m)O(m)

所以总的时间复杂度为 O(n^2)O(n2)

稠密图用邻接矩阵存图。

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

using namespace std;

const int N = 510;

int g[N][N], dis[N];
bool vis[N];   // 依据访问过与否将所有节点分成两个部分(集合)

int n, m;

void dijkstra(int s)
{
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0;
    for(int i = 1; i <= n; i++)
    {
        // 确定集合中距离初始节点最近的点 t
        int t = -1;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && (t == -1 || dis[j] < dis[t]))
                t = j;
        }
        vis[t] = true; // 加入 S 集合
        // 从 t 出发，更新相邻点的 dis
        for(int j = 1; j <= n; j++)
            dis[j] = min(dis[j], dis[t] + g[t][j]);
    }
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(g, 0x3f, sizeof(g));
    while (m--)
    {
        int x, y, c;
        scanf("%d%d%d", &x, &y, &c);
        g[x][y] = min(g[x][y], c);   // 因为有重边，所以只保留最短边
    }
    dijkstra(1);
    if(dis[n] == 0x3f3f3f3f) cout << -1;
    else cout << dis[n];
    return 0;
}

练习题

堆优化 Dijkstra

任何场景均适合(正边权)

思路

堆优化版的Dijkstra是对朴素版Dijkstra进行了优化，在朴素版Dijkstra中时间复杂度最高的寻找距离最短的点 O(n^2)O(n2) 可以使用最小堆优化。

1 号点的距离初始化为零，其他点初始化成无穷大。
将一号点放入堆中。
不断循环，直到堆空。每一次循环中执行的操作为：弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定）。用该点更新临界点的距离，若更新成功就加入到堆中。

时间复杂度分析

寻找路径最短的点：O(n)O(n)

加入集合S：O(n)O(n)

更新距离：O(mlogn)O(mlogn)

所以总的时间复杂度为 O((mlogn)O((mlogn)

#include<bits/stdc++.h>

using namespace std;

const int N = 150010;
struct edge {
    int y, w;
};
vector<edge> g[N];
int dis[N];
bool vis[N];   // 依据访问过与否将所有节点分成两个部分(集合)

int n, m;

void dijkstra(int s)
{
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0;
    priority_queue<pair<int, int> > q; // 大根堆写好 
    q.push(make_pair(0, s)); 
    // q.push(pair<int,int>(0, s)); 
    while(!q.empty())
    {
        // 找出距离最近的点  O(log n)
        int c = -1*q.top().first, x = q.top().second;
        q.pop();
        if(vis[x]) continue; 
        // 加入 S 集合
        vis[x] = true; 
        // 从 x 出发，更新相邻点的 dis
        for(int j = 0; j < g[x].size(); j++)
        {
            int y = g[x][j].y, w = g[x][j].w;
            if(dis[y] > dis[x] + w)
            {
                dis[y] = dis[x] + w;
                q.push(make_pair(-1*dis[y], y));
            }
        }
    }
}
int main()
{
    cin >> n >> m;
    while (m--)
    {
        int x, y, c;
        cin >> x >> y >> c;
        g[x].push_back((edge){y, c});
    }
    dijkstra(1);
    if(dis[n] == 0x3f3f3f3f) cout << -1;
    else cout << dis[n];
    return 0;
}

Copy

结构体写法

#include<bits/stdc++.h>
using namespace std;

const int N = 1.5e5+5;
struct Edge{
    int v, w;
    bool operator <(const Edge& rhs) const {
        return w > rhs.w;
    }
};
int dis[N];
bool vis[N];   // 依据访问过与否将所有节点分成两个部分(集合)
vector<Edge> g[N];
int n, m;

void dijkstra(int s)
{
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    dis[s] = 0;
    priority_queue<Edge> pq;
    pq.push({s, 0});
    while(!pq.empty()) {
        auto u = pq.top().v; pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(auto e : g[u]) {
            int v = e.v, w = e.w;
            if(dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                pq.push({v, dis[v]});
            }
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    while (m--)
    {
        int x, y, c;
        scanf("%d%d%d", &x, &y, &c);
        g[x].push_back({y, c});
    }
    dijkstra(1);
    if(dis[n] == 0x3f3f3f3f) cout << -1;
    else cout << dis[n];
    return 0;
}

Copy

链式前向星写法

#include<iostream>
#include<cstring>
#include<queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 150010;

int h[N], e[N], ne[N], idx;
int w[N]; // 用来存权重
int dist[N];
bool st[N]; // 如果为true说明这个点的最短路径已经确定

int n, m;

// 稀疏图用链式前向星来存
void add(int x, int y, int c)
{
    w[idx] = c; // 有重边也不要紧，假设1->2有权重为2和3的边，再遍历到点1的时候2号点的距离会更新两次放入堆中
    e[idx] = y; // 这样堆中会有很多冗余的点，但是在弹出的时候还是会弹出最小值2+x（x为之前确定的最短路径），并
    ne[idx] = h[x]; // 标记st为true，所以下一次弹出3+x会continue不会向下执行。
    h[x] = idx++;
}

int dijkstra()
{
    memset(dist, 0x3f, sizeof(dist));
    dist[0] = 1;
    priority_queue<PII, vector<PII>, greater<PII>> q; // 定义一个小根堆
    // 这里heap中为什么要存pair呢，首先小根堆是根据距离来排的，所以有一个变量要是距离，其次在从堆中拿出来的时    
    // 候要知道知道这个点是哪个点，不然怎么更新邻接点呢？所以第二个变量要存点。
    q.push({ 0, 1 }); // 这个顺序不能倒，pair排序时是先根据first，再根据second，这里显然要根据距离排序
    while(!q.empty())
    {
        PII k = q.top(); // 取不在集合S中距离最短的点
        q.pop();
        int ver = k.second, distance = k.first;

        if(st[ver]) continue;
        st[ver] = true;  // 加入集合 S 中
    
        for(int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i]; // i只是个下标，e中在存的是i这个下标对应的点。
            if(dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                q.push({ dist[j], j });
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    else return dist[n];
}

int main()
{
    memset(h, -1, sizeof(h));
    scanf("%d%d", &n, &m);

    while (m--)
    {
        int x, y, c;
        scanf("%d%d%d", &x, &y, &c);
        add(x, y, c);
    }
    
    cout << dijkstra() << endl;
    
    return 0;
}