Dijkstra算法的两种写法和时间复杂度计算

Dijkstra算法是一种单源最短路径算法，是 BFS 的延伸

基于集合的写法 （适用于稠密图）

算法

1. 初始化距离向量 $d$（长度为 $V$），起点设为0，其他点设为无穷大
2. 初始化集合 $Q$，含义为尚未确定距离的顶点的集合，将所有顶点加入
3. 从 $Q$ 中弹出距离最小的顶点 $u$
4. 遍历 $u$ 的所有仍在 $Q$ 中的邻居 $w$， 判断 $d[u]+length(u,w)<d[w]$是否成立，如果成立，更新 $d[w]=d[u]+length(u,w)$, 否则无视
5. 回到 3 开始循环，直到 $Q$ 为空集

示例代码

def dijkstra(n, edges, weights, start, end):
	# Construct graph
	neighbors = [[] for j in range(n)]
	for j, edge in enumerate(edges):
		neighbors[edge[0]].append((edge[1], weights[j]))
        neighbors[edge[1]].append((edge[0], weights[j]))
    
    # Initialize d
    d = [float('inf')] * n
    d[start] = 0

	# Initialize Q
	Q = set()
	for j in range(n):
		Q.add(j)

	# Start loop
	while Q:
		# Extract-min from Q
		minv = float('inf')
		u = -1
		for j, x in enumerate(d):
		    if x < minv and x in Q:
		        minv = x
		        u = j
		Q.remove(u)
	
		# Update neighbors of u
		for e in neighbors[u]:
			w = e[0]
			weight = e[1]
			if w in Q:
				alt = d[u] + weight
				if alt < d[w]:
					d[w] = alt
	return d[end]

复杂度

1. 初始化 $d$ 和 $Q$ 均为 $O(V)$
2. 外层循环，每次删除一个顶点，共 $V$ 个顶点，故为 $O(V)$
3. 内层 Extrac-min 为 $O(V)$，遍历邻居为 $O(N)$ （$N$ 为每个节点最大的邻居数）

综上，复杂度为 $O(V)+O(V^2)+O(VN)\sim O(V^2)$

基于优先队列的写法（适用于稀疏图）

算法

1. 初始化距离向量 $d$（长度为 $V$），起点设为0，其他点设为无穷大
2. 初始化优先队列 $Q$： 对所有顶点 $v$, 将 $(d[v],v)$ 推入 $Q$
3. 初始化 $visited$ 为空集
4. 从 $Q$ 中弹出距离最小的顶点 $u$， 加入 $visited$
5. 遍历 $u$ 的所有未在 $visited$ 中的邻居 $w$， 判断 $d[u]+length(u,w)<d[w]$是否成立，如果成立，更新 $d[w]=d[u]+length(u,w)$ 并将 $(d[w],w)$ 推入 $Q$, 否则无视
6. 回到 3 开始循环，直到 $Q$ 为空集

示例代码

import heapq
def dijkstra(n, edges, weights, start, end):
	# Construct graph
	neighbors = [[] for j in range(n)]
	for j, edge in enumerate(edges):
		neighbors[edge[0]].append((edge[1], weights[j]))
        neighbors[edge[1]].append((edge[0], weights[j]))
    
    # Initialize d
    d = [float('inf')] * n
    d[start] = 0

	# Initialize Q
	Q = []
	for v in range(n):
		heapq.heappush(Q, (d[v], v))
	
	# Initialize visited
	visited = set()
	
	# Start loop
	while Q:
		u = heapq.heappop(Q)[1]
		if u in visited:
			continue
		visited.add(u)
		for e in neighbors[u]:
			w = e[0]
			if w not in visited:
				weight = e[1]
				alt = d[u] + weight
				if alt < d[w]:
					d[w] = alt
					heapq.heappush(Q, (d[w], w))
	return d[end]

复杂度

1. 初始化 $d$ 为 $O(V)$，初始化 $Q$ 为 $O(V\log V)$
2. 外层循环 $O(V)$
3. 内层循环 （遍历所有邻居）为 $O(N)$
4. 更新邻居为 $O(\log (V))$

综上，总复杂度为 $O(VN\log V)$ （或写为 $O(E\log V)$）

两者比较

基于优先队列的写法节约了每次寻找距离最小顶点的开销 $O(V)$，然而增加了每次更新邻居的开销 $O(\log V)$. 当图稀疏时，$V^2\gg E$，后者更优；当图稠密时，$V^2\sim E$，前者更优