Dijkstra 算法

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;}

Copy

练习题

• P2778 Dijkstra求最短路 I
• P2298 最优乘车
• P2370 平面最短路径问题

堆优化 Dijkstra

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

思路

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

1. 1 号点的距离初始化为零，其他点初始化成无穷大。
2. 将一号点放入堆中。
3. 不断循环，直到堆空。每一次循环中执行的操作为： 弹出堆顶（与朴素版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;}

Copy

练习题

• P2780 Dijkstra求最短路 II
• P2299 热浪
• P2372 香甜的黄油

练习题

• P2779 奶牛跨栏(Cow Hurdles)
• P2370 平面最短路径问题