D i j k s t r a Dijkstra Dijkstra是最常用，效率最高的最短路径算法，是单源最短路算法。核心是 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
3 3
1 2 5
2 3 2
1 3 10输出样例1
7详细解释见代码注释
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;
}易错提示：不要忘记初始化，不要忘记初始化，不要忘记初始化。