前言：

Dijkstra算法博客讲解分为两篇讲解，这两篇博客对所有有难点的问题都会讲解，小白也能很好理解。看完这两篇博客后保证收获满满。

第一篇博客讲解朴素Dijkstra算法Dijkstra求最短路篇一(全网最详细讲解两种方法，适合小白)(python，其他语言也适用)，本篇博客讲解堆优化Dijkstra算法，两中算法思路大体相同，但时间复杂度有所区别。

• 朴素Dijkstra算法：时间复杂度$O(n^2)$
• 堆优化Dijkstra算法：时间复杂度$O(mlogn)$

两篇博客给出的题目内容一样，只有数据规模不一样。

题目：

题目链接：
850. Dijkstra求最短路 II

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。

数据范围（两题不同处）
$1\le n,m\le 1.5\times 10^5$,
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过 $10^9$。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

思路：

算法分析：

依旧是Dijkstra算法求解，不同的是本题需要降低时间复杂度。

对朴素Dijkstra算法时间复杂度分析可知：

• 寻找路径最短的点：$O(n^2)$
• 加入集合S：$O(n)$
• 更新距离：$O(m)$
• 所以总的时间复杂度为$O(n^2)$

所以我们需要对寻找路径最短的点进行改变，如何降低找最短距离的点的时间复杂度呢？
这里可以使用最小堆进行优化（也就是优先队列），对优先队列不太熟悉的可以看看优先队列这篇博客，其他博主写的很详细这里我就不介绍了。

进行优化后时间复杂度分析如下：

• 寻找路径最短的点：$O(n)$
• 加入集合S：$O(n)$
• 更新距离：$O(mlogn)$

堆的数据结构大家接触的可能有点少，python中有专门的库函数可以直接使用，其他语言也有类似的库函数可以使用。

构造邻接表：

首先对数据进行存储，图的存储有两种方式，一种是邻接表，一种是邻接矩阵。题目中的数据规模用邻接表存储（本题数据规模是稀疏图）。

为什么要用邻接表去存贮，而不是邻接矩阵？

我们采用邻接矩阵还是采用邻接表来表示图，需要判断一个图是稀疏图还是稠密图。稠密图指的是边的条数|E|接近于|V|²，稀疏图是指边的条数|E|远小于于|V|²（数量级差很多）。本题是稠密图，显然稠密图用邻接矩阵存储比较节省空间，反之用邻接表存储。

邻接表存储就不需要注意重边和自环了，因为算法会自动算出最优解

邻接矩阵存储代码如下：

n, m = map(int, input().split())  # 图的节点个数和边数
#  构建邻接表 
num = [[] for i in range(n + 1)]
for _ in range(m):
    a, b, c = map(int, input().split())
    num[a].append((b, c))  # 无需考虑重边和自环

以题目实例为例，打印num数组

[[], [(2, 2), (3, 4)], [(3, 1)], []]

邻接表构建完成之后就要进行Dijkstra算法，这里直接给出代码，用详细代码给大家进行讲解。整体思路跟朴素Dijkstra算法大致相同

代码及详细注释：

import heapq

n, m = map(int, input().split())  # 图的节点个数和边数
#  构建邻接表 
num = [[] for i in range(n + 1)]
for _ in range(m):
    a, b, c = map(int, input().split())
    num[a].append((b, c))  # 无需考虑重边和自环
dist = [float("inf") for _ in range(n + 1)]  # float("inf")在python中是无限大的意思
dist[1] = 0  # 源点到源点的距离为置为 0
state = [False for i in range(n + 1)]  # state 用于记录该点的最短距离是否已经确定


def dijstra():
    # 这里heap中为什么要存两个值呢，首先小根堆是根据距离来排的，所以有一个变量要是距离，
    # 其次在从堆中拿出来的时候要知道知道这个点是哪个点，不然怎么更新邻接点呢？所以第二个变量要存点。
    heap = [(0, 1)]  # 首先放入距离0和点1，这个顺序不能倒，这里显然要根据距离排序
    while heap:
        distance, i = heapq.heappop(heap)  # 这里是取出最下距离和对应的点，最小堆自动取出最小值
        if state[i]:  # 如果该点最短距离已经确定，跳过下面操作
            continue
        state[i] = True  # 标记该点距离确定
        for j, d in num[i]:  # 循环遍历找点i所能到的点和其距离
            if dist[j] > distance + d:  # 如果原本点j到源点的距离大于后续计算出来的值
                dist[j] = distance + d  # 更新
                heapq.heappush(heap, (dist[j], j))  # 该点距离和点加入到最小堆中

    # 判断最后一个点的最短距离是否找到，如果为无穷大，则表示未找到，返回-1，否则返回最短距离dist[-1]
    if dist[n] == float("inf"):
        return -1
    else:
        return dist[n]


print(dijstra())

朴素Dijkstra算法大家理解好了本算法也很好理解，操作都是一样，只是在寻找路径最短的点时用了最小堆操作。这里就不拿实例带大家过了，如果略微有点懵，大家可以自己拿实例数据过一遍。

本题主要对 Python 中的 heapq 库进行简略讲解。

import heapq

heap = []
heapq.heappush(heap, (1, 2))
heapq.heappush(heap, (1, 3))
heapq.heappush(heap, (2, 1))
heapq.heappush(heap, (2, 0))
heapq.heappush(heap, (0, 2))
heapq.heappush(heap, (0, 0))

print("初始状态", heap)
print("删除的元素", heapq.heappop(heap))
print("删除后状态", heap)

运行结果：

初始状态 [(0, 0), (1, 2), (0, 2), (2, 0), (1, 3), (2, 1)]
删除的元素 (0, 0)
删除后状态 [(0, 2), (1, 2), (2, 1), (2, 0), (1, 3)]

• heapq.heappush（(heap, (1, 2)）：把元素（1，2）加入到堆 heap中（每次加入后都是最小堆的构建形式）。
• heapq.heappop(heap)：弹出堆顶元素（最小堆的堆顶就是最小元素）。

总结：

堆优化版dijkstra适合稀疏图

思路：

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

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

时间复杂度分析

• 寻找路径最短的点：$O(n)$
• 加入集合S：$O(n)$
• 更新距离：$O(mlogn)$