Python算法模版：图论中的最短路径算法

最新推荐文章于 2024-09-08 23:57:49 发布

山海不见君

最新推荐文章于 2024-09-08 23:57:49 发布

阅读量527

点赞数 12

分类专栏： Python算法模版文章标签：图论 python 算法

本文链接：https://blog.csdn.net/2301_77408198/article/details/140300543

版权

Python算法模版专栏收录该内容

2 篇文章 2 订阅

订阅专栏

这一篇主要记录在图论中求最短路径的几个算法的python模版，用于本人日后忘记的话复习用，对于有问题的地方，大家也可以在评论区指导一下。

单源最短路径算法：Dijkstra

对于Dijkstra来说，他的所有边必须是正权边，也就是说他无法解决边权存在负数的情况，时间复杂度为nlogm

首先对于题目所给的数据进行处理，一般我们将其放入矩阵，将边和边的权值放入列表list_g中去

n,m=map(int,input().split())
inf=1e6
list_g = [[inf] * (n+1) for i in range(n+1)]
for _ in m:
    u,v,w=map(int,input().split())
    list_g[u][v] = list_g[v][u]=min(list_g[u][v],w)

然后开始写Dijkstra算法，我们令k为起点

def dsk(list_g,n,k):
    dist, s = [inf] * (n+1), [False] * (n+1)
    dist[k] = 0
    for i in range(n):
        x = -1
        #找最小值
        for j in range(1,n+1):
            if not s[j] and (x == -1 or dist[j] < dist[x]):
                x = j
        #标记最小值
        s[x] = True
        #遍历图
        for j in range(1,n+1):
            dist[j] = min(dist[j], dist[x] + list_g[x][j])

还有一种模版利用分支限界法里面优先队列的方式来实现Dijkstra，首先要先导入Python里自带的优先队列

from queue import PriorityQueue

def fun(s):
    d=[inf] * (n+1)
    vis = [0] * (n+1)
    q = PriorityQueue()

    d[s]=0
    q.put((d[s],s))
    while not q.empty():
        dis , u = q.get()
        if vis[u]:continue
        vis[u]=1
        for i in range(1,n+1):
            if d[v] > d[u] + list_g[u][v]
                d[v] = d[u] + list_g[u][v]
                q.put((d[v],v))

单源最短路径算法：Bellman-Ford

Bellman-Ford算法可以处理存在负权值的情况，时间复杂度为nm，数据处理如下

n, m = map(int, input().split())
s = []
for i in range(m):
    u, v, w = map(int, input().split())
    s.append((u, v, w))
    s.append((v, u, w))

核心思想就是遍历n-1边，如果还能更新，也就是说存在负权回路，一般题目没有，除非强调，判断自己也可以手动添加

inf = 1e9
d = [inf] * (n + 1)
d[1] = 0

for _ in range(n - 1):
    for u, v, w in s:
        if d[v] > d[u] + w:
            d[v] = d[u] + w

多源最短路径算法：Floyd

Floyd的时间复杂度为n^3，碰到大数量级别的例子直接是超时的，也不建议使用，最开始用矩阵来存储数据

INF = 1e6

n, m, q = map(int, input().split())
dis = [[INF] * (n + 1) for _ in range(n + 1)]

for i in range(1, n + 1):
    dis[i][i] = 0

for _ in range(m):
    u, v, w = map(int, input().split())
    dis[u][v] = dis[v][u] = min(dis[u][v], w)

开始写框架，更新最小路径

for k in range(1, n + 1):
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j])