蓝桥杯 之 最短路径算法

• 求解最短路径：总共是有三种算法
  • 当边的权重为1，也就是不同的点之间的边的距离使用边的数量的时候，就可以使用这个BFS算法，该算法使用优先队列进行求解，当队列不为空的时候，就弹出队首的元素，然后将没有访问过的队首的邻居的距离更新
  • 当边的权重的计算不是单纯的1的时候，如果求解的是单源点到剩余节点的最短路径的问题，那么就可以考虑使用这个Dijkstra算法
  • 如果边的权重不是单纯的1，并且求解的是多源点到剩余节点的最短路径的问题，那么就可以使用这个Floyd算法

BFS算法

• 在这里就只介绍算法模版，具体的算法介绍请看我的另一篇博客

from collections import deque
def dfs(start):
	# 将起点加入队列
	queue = deque([start])
	# 既是记录start到剩余节点的距离，又可以标注是否访问过
	visited = {start:0}
	while queue:
		# 弹出队首的元素
		node = queue.popleft()
		# 访问node节点的邻居,这里假设使用的是邻接表存储
		for neigh in e[node]:
			# 如果这个邻居没有被访问
			if neigh not in visited:
			# 更新距离并加入队列
				visited[neigh] = visited[node] + 1
				queue.append(neigh)
	return visited

Dijkstra算法

• Dijkstra算法存在两种写法，一种是朴素的Dijkstra算法，一种是使用堆栈优化的算法，在这里我只对于堆栈优化的Dijkstra算法进行归纳，具体的算法总结请看我的另一篇博客
• Dijkstra算法的核心就是把这个节点分为已经找到距离的，和没有找到距离的，每次从没有找到距离的节点中找到距离找到距离的最近的那一个节点，加入找到距离的节点当中，然后更新该节点的邻居，当然，只有得到更短距离才更新并加入堆当中
• Dijkstra算法与这个BFS算法最大的算法区别就是，使用了队列的BFS算法的队列当中是不存在冗余的，但是使用了堆的Dijkstra算法就会出现很多冗余的情况，所以当出堆的时候，当出堆记录的距离大于已经记录好的距离，就说明该节点已经出过堆了，现在的记录的信息是冗余的，直接跳过

import heapq

def dijkstra(start):
	# 初始化堆
	h = [(0,start)]
	# 记录start节点到达剩余节点的距离
	dis = [float("inf")]*N
	dis[start] = 0
	# 开始堆操作
	while h:
		# 出堆
		dx,x = heapq.heappop(h)
		# 如果成立，说明节点x已经出过堆了，现在的信息是冗余的
		if dx > dis[x]:
			continue 
		# 访问节点x的邻居,假设使用的是邻接表e,e中每一个元素存储的是(node,dis)
		for y,dy in e[start]:
			newdis = dx + dy
			# 如果满足距离更短，就更新距离以及入堆
			if newdis < dis[y]:
				dis[y] = newdis
				heapq.heappush(h,(dis[y],y))
	# 最终这个dis数组记录了start到剩余节点的最短距离
	return dis

Floyd算法

• 相比于Dijkstra算法，Floyd算法可以从这个递归中求解出来，这里只介绍算法模版，具体的代码请看我的另一篇博客

from functools import lru_cache
# 使用记忆化搜索
@lru_cache(maxsize=None)
def dfs(k,i,j):# 定义从从节点i到节点j的，经过最大节点号不超过k的最短距离
	if k <0 :
		# w[i][j] 为邻接矩阵，表示节点i到节点j的边的权值
		return w[i][j]
	# 有两种选择，一个是不选节点k，一种是选节点k，取其中的较小值
	return min(dfs(k-1,i,j),dfs(k-1,i,k)+dfs(k-1,k,j))
	

变形与转化

总结