算法学习笔记（最短路——Dijkstra）

D i j k s t r a Dijkstra Dijkstra是最常用，效率最高的最短路径算法，是单源最短路算法。核心是 B F S BFS BFS和贪心。

B F S BFS BFS传送门

D i j k s t r a Dijkstra Dijkstra大概分成以下几个步骤：

从起点出发扩展它的邻点。
选择一个最近的邻点继续向外拓展它的邻点。（贪心的思想，保证了拓展完之后该点一定是最短路径，不用重复拓展。若从不是从距离最近的点向外拓展，可能存在一条路从起点经过最近点到达该点，就需要重复计算。）
重复步骤 2 2 2直到所有点都被拓展过了。

如何快速地取得步骤 2 2 2中描述的所谓最近邻点？可以使用优先队列来实现。就是说用优先队列来代替原来 B F S BFS BFS中的普通队列。

算法复杂度： O ( m l o g 2 n ) O(mlog_2n) O(mlog2n)。

算法缺点：边权不能为负数，若出现负边，则上述贪心思想失效（出现从另外一点经过一负边到达"最近点"的距离比原本到达"最近点"的距离短）。

存图：邻接表、前向星。

例题：【模板】最短路（2）- StarryCoding | 踏出编程第一步

题目描述

给定一个 n n n个点、 m m m条边的有向图，要求计算出点 1 1 1到点 n n n的最短距离。

可能存在重边和自环。

输入描述

第一行：两个整数 n , m n,m n,m。（ 1 ≤ n , m ≤ 2 × 1 0 5 1 \le n,m \le 2 \times 10^5 1≤n,m≤2×105）

接下来 m m m行：每行三个整数 u i , v i , w i u_i,v_i,w_i ui,vi,wi，表示存在一条从 u i u_i ui到 v i v_i vi，权值为 w i w_i wi的有向边。 ( 1 ≤ u i , v i ≤ n , 1 ≤ w i ≤ 1 0 6 ) (1 \le u_i, v_i \le n, 1 \le w_i \le 10^6) (1≤ui,vi≤n,1≤wi≤106)

可能存在重边和自环。

输出描述

一个整数，表示从 1 1 1到点 n n n的最短距离；若不存在从点 1 1 1到点 n n n的路径，则输出 − 1 −1 −1。

输入样例1

输出样例1

详细解释见代码注释

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 9;
const ll inf = 4e18;

int n, m;

struct Edge     //记录边
{
    int x; ll w;        //x:出点，w:边权
    bool operator < (const Edge &v) const   //重载运算符实现小根堆
    {
        return w > v.w;
    }
};

vector<Edge> g[N];      //邻接矩阵存图
int vis[N];     //记录第i点是否被拓展过
ll d[N];        //d[i]表示从起点到点i的最短路径长度

void dijkstra(int st)
{
    for(int i = 1; i <= n; ++i)     //初始化不要忘记
    {
        d[i] = inf;
    }
    d[st] = 0;

    //BFS
    priority_queue<Edge> q;
    q.push({st, d[st]});        //将起点存入优先队列

    while(q.size())
    {
        int x = q.top().x;
        q.pop();

        //已经拓展过的点不再拓展，因为已经求得了最短路
        if(vis[x])continue;
        vis[x] = 1;
        
        for(auto &[y, w] : g[x])
        {
            //若出点也没拓展过且可以拓展，加入待拓展队列
            if(!vis[y] && d[y] > d[x] + w)
            {
                d[y] = d[x] + w;
                q.push({y, d[y]});
            }
        }
    }
}

void solve()
{
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        int u, v, w; cin >> u >> v >> w;
        g[u].push_back({v, w});
    }

    dijkstra(1);

    cout << (d[n] == inf ? -1 : d[n]) << '\n';
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int _ = 1;
    while(_--) solve();
    return 0;
}

易错提示：不要忘记初始化，不要忘记初始化，不要忘记初始化。