精华内容
下载资源
问答
  • 主要介绍了Python基于Floyd算法求解最短路径距离问题,结合完整实例形式详细分析了Python使用Floyd算法求解最短路径距离问题的相关操作技巧与注意事项,需要的朋友可以参考下
  • python实现Floyd算法

    2020-09-20 22:29:43
    主要为大家详细介绍了python实现Floyd算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 最短路:Floyd算法(Python实现)

    千次阅读 2020-10-19 11:16:37
    Floyd算法原理是动态规划。 算法描述 开始:对于每一对顶点v和v’,从v到v’图中不经过任何其他顶点,如果v到v’存在边,那么长度就是该边的权,如果没边就设长度为无穷大 k=0k=0k=0:即对于每一对顶点v和v’,途径顶点...

    Floyd-Warshall算法是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权(但不可存在负权回路)的最短路径问题。Floyd算法的根本原理是动态规划
    在这里插入图片描述

    算法描述

    开始:对于每一对顶点 v v v v ′ v' v,从 v v v v ′ v' v图中不经过任何其他顶点,如果 v v v v ′ v' v存在边,那么长度就是该边的权,如果没边就设长度为无穷大

    k = 0 k=0 k=0:即对于每一对顶点v和v’,途径顶点的下标不大于 k k k,实际上这里只能经过 v 0 v_0 v0,该路径可分为两段,即 < v , v 0 > <v,v_0> <v,v0> < v 0 , v ′ > <v_0,v'> <v0,v>,这一长度就是两段路径的长度之和,比较这一新路径和之前的路径 < v , v ′ > <v,v'> <v,v>,就可以确定 v v v v ′ v' v途经下标不大于k的最短路径

    k = 1 k=1 k=1:同理,该路径可拆成 < v , … , v 1 > <v,… ,v_1> <v,,v1> < v 1 , … , v ′ > <v_1,…,v'> <v1,,v>两段,这两段的长度在 k = 0 k=0 k=0的时候就确定了,再比较新路径和前面已知的路径 < v , v ′ > <v,v'> <v,v>就可以确定途经下标不大于 k k k的最短路径,此时 k = 1 k=1 k=1
    重复以上步骤,直到 k = n − 1 k=n-1 k=n1为止,此时已经确定了从 v v v v ′ v' v所有可能的最短路径

    代码实现

    在这里插入图片描述
    对于上图,可以用邻接字典表表示,然后Floyd算法需要将其转为邻接矩阵形式:

    graph = {'A': [(7, 'A', 'B'), (5, 'A', 'D')], 
             'B': [(7, 'B', 'A'), (8, 'B', 'C'), (9, 'B', 'D'), (7, 'B', 'E')], 
             'C': [(8, 'C', 'B'), (5, 'C', 'E')],
             'D': [(5, 'D', 'A'), (9, 'D', 'B'), (15, 'D', 'E'), (6, 'D', 'F')], 
             'E': [(7, 'E', 'B'), (5, 'E', 'C'), (15, 'E', 'D'), (8, 'E', 'F'), (9, 'E', 'G')], 
             'F': [(6, 'F', 'D'), (8, 'F', 'E'), (11, 'F', 'G')],
             'G': [(9, 'G', 'E'), (11, 'G', 'F')]
            }
    def graph2adjacent_matrix(graph):
        vnum = len(graph)
        dict = {'A':0,'B':1,'C':2,'D':3,'E':4,'F':5,'G':6}
        adjacent_matrix = [[0 if row==col else float('inf') for col in range(vnum)] for row in range(vnum)]
        vertices = graph.keys()
        for vertex in vertices:
            for edge in graph[vertex]:
                w,u,v = edge
                adjacent_matrix[dict.get(u)][dict.get(v)]=w
        return adjacent_matrix
    

    然后运用floyd算法:

    def floyd(adjacent_matrix):
        vnum = len(adjacent_matrix)
        a = [[adjacent_matrix[row][col] for col in range(vnum)] for row in range(vnum)]
        nvertex = [[-1 if adjacent_matrix[row][col]==float('inf') else col for col in range(vnum)] for row in range(vnum)]
        # print(adjacent_matrix)
        for k in range(vnum):
            for i in range(vnum):
                for j in range(vnum):
                    if a[i][j]>a[i][k]+a[k][j]:
                        a[i][j]=a[i][k]+a[k][j] 
                        nvertex[i][j] = nvertex[i][k]
        return nvertex, a
    
    adjacent_matrix = graph2adjacent_matrix(graph)
    nvertex, a = floyd(adjacent_matrix)
    ### 打印原邻接矩阵 ###
    for i in range(len(adjacent_matrix)):
        for j in range(len(adjacent_matrix[0])):
            print(adjacent_matrix[i][j],end="\t")
        print()#打印一行后换行
    ### 打印经过的顶点 ###
    print()
    for i in range(len(nvertex)):
        for j in range(len(nvertex[0])):
            print(nvertex[i][j],end="\t")
        print()#打印一行后换行
    ### 打印彼此之间的最短距离 ###
    print()
    for i in range(len(a)):
        for j in range(len(a[0])):
            print(a[i][j],end="\t")
        print()#打印一行后换行
    

    其中a表示最短距离矩阵,即a[0][6]表示点AG之间的最短距离,而nvertex矩阵中的nvertex[i][j]表示 v i v_i vi v j v_j vj之间最短路中 v i v_i vi的后继顶点,根据该矩阵可以之后任意最短路中间经过的顶点,如下给出该矩阵:
    在这里插入图片描述
    我们找出A到G最短路中间经过的顶点,A对应0,G对应6,我们找到nvertex[0][6]=3,也就是A到G的最短路A的后继是D,即A->D->…->G,我们在找D和G,即nvertex[3][6]=5,即D的后继是F,然后找nvertex[5][6]=6,F的后继是G,最后A到G的最短路就是A->D->F->G。

    展开全文
  • 一步一步带你实现弗洛伊德算法

    基本概述

    • 弗洛伊德算法介绍
      在这里插入图片描述
    • 图解分析
      在这里插入图片描述
      在这里插入图片描述
    • 算法步骤
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

    Python实现

    在这里插入图片描述

    # 弗洛伊德算法
    
    class Graph(object):
        def __init__(self, length: int, matrix: [], vertex: []):
            """
            :param length: 大小
            :param matrix: 邻接矩阵
            :param vertex: 顶点数组
            """
            # 保存,从各个顶点出发到其它顶点的距离,最后的结果,也保留在该数组
            self.dis = matrix
            # 保存到达目标顶点的前驱顶点
            self.pre = [[0 for col in range(length)] for row in range(length)]
            self.vertex = vertex
            # 对 pre数组进行初始化,存放的是前驱顶点的下标
            for i in range(length):
                for j in range(length):
                    self.pre[i][j] = i
    
        # 显示pre数组和dis数组
        def show_graph(self):
            # 为了显示便于阅读,优化一下
            for k in range(len(self.dis)):
                # 先将pre数组输出的一行
                for i in range(len(self.dis)):
                    # print(self.pre[k][i], end=" ")
                    print(self.vertex[self.pre[k][i]], end=" ")
                # 输出dis数组的一行数据
                print()
                for i in range(len(self.dis)):
                    print('({}到{}的最短路径是{})'.format(self.vertex[k], self.vertex[i], self.dis[k][i]), end=" ")
                print()
                print()
    
        # 佛洛依德算法
        def floyd(self):
            length: int = 0  # 变量保存距离
            # 对中间顶点的遍历,k 就是中间顶点的下标
            for k in range(len(self.dis)):  # ['A', 'B', 'C', 'D', 'E', 'F', 'G']
                # 从 i顶点开始出发['A', 'B', 'C', 'D', 'E', 'F', 'G']
                for i in range(len(self.dis)):
                    # 到达j顶点 ['A', 'B', 'C', 'D', 'E', 'F', 'G']
                    for j in range(len(self.dis)):
                        length = self.dis[i][k] + self.dis[k][j]  # 求出从i 顶点出发,经过k中间顶点,到达j顶点距离
                        if length < self.dis[i][j]:  # 如果length 小于dis[i][j]
                            self.dis[i][j] = length  # 更新距离
                            self.pre[i][j] = self.pre[k][j]  # 更新前驱顶点
    
    
    if __name__ == '__main__':
        vertex: [] = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
        # 邻接矩阵
        matrix: [] = [[0 for col in range(len(vertex))] for row in range(len(vertex))]
        # 用来表示一个极大的数
        F: float = float('inf')
        matrix[0] = [0, 5, 7, F, F, F, 2]
        matrix[1] = [5, 0, F, 9, F, F, 3]
        matrix[2] = [7, F, 0, F, 8, F, F]
        matrix[3] = [F, 9, F, 0, F, 4, F]
        matrix[4] = [F, F, 8, F, 0, 5, 4]
        matrix[5] = [F, F, F, 4, 5, 0, 6]
        matrix[6] = [2, 3, F, F, 4, 6, 0]
        g = Graph(len(vertex), matrix, vertex)
        # 调用弗洛伊德算法
        g.floyd()
        g.show_graph()
    '''输出结果
    A A A F G G A 
    (A到A的最短路径是0) (A到B的最短路径是5) (A到C的最短路径是7) (A到D的最短路径是12) (A到E的最短路径是6) (A到F的最短路径是8) (A到G的最短路径是2) 
    
    B B A B G G B 
    (B到A的最短路径是5) (B到B的最短路径是0) (B到C的最短路径是12) (B到D的最短路径是9) (B到E的最短路径是7) (B到F的最短路径是9) (B到G的最短路径是3) 
    
    C A C F C E A 
    (C到A的最短路径是7) (C到B的最短路径是12) (C到C的最短路径是0) (C到D的最短路径是17) (C到E的最短路径是8) (C到F的最短路径是13) (C到G的最短路径是9) 
    
    G D E D F D F 
    (D到A的最短路径是12) (D到B的最短路径是9) (D到C的最短路径是17) (D到D的最短路径是0) (D到E的最短路径是9) (D到F的最短路径是4) (D到G的最短路径是10) 
    
    G G E F E E E 
    (E到A的最短路径是6) (E到B的最短路径是7) (E到C的最短路径是8) (E到D的最短路径是9) (E到E的最短路径是0) (E到F的最短路径是5) (E到G的最短路径是4) 
    
    G G E F F F F 
    (F到A的最短路径是8) (F到B的最短路径是9) (F到C的最短路径是13) (F到D的最短路径是4) (F到E的最短路径是5) (F到F的最短路径是0) (F到G的最短路径是6) 
    
    G G A F G G G 
    (G到A的最短路径是2) (G到B的最短路径是3) (G到C的最短路径是9) (G到D的最短路径是10) (G到E的最短路径是4) (G到F的最短路径是6) (G到G的最短路径是0) 
    '''
    
    
    展开全文
  • Floyd-Warshall算法python代码

    千次阅读 2017-03-12 22:05:22
    华电北风吹 2017年3月12日未连接的边需要赋一个初始值,可以把矩阵所有...import sysdef Floyd(Graph,ShortestPath,PathCount): NodeNum=len(Graph) lastShortestDistance=[[0 for i in range(NodeNum)] for j in ran

    华电北风吹
    2017年3月12日

    未连接的边需要赋一个初始值,可以把矩阵所有元素值相加再加1。附加功能是计算最短路径的条数。

    import sys
    
    def Floyd(Graph,ShortestPath,PathCount):
        NodeNum=len(Graph)
    
        lastShortestDistance=[[0 for i in range(NodeNum)] for j in range(NodeNum)]
        lastPathCount=[[0 for i in range(NodeNum)] for j in range(NodeNum)]
    
        currentShortestDistance=[[0 for i in range(NodeNum)] for j in range(NodeNum)]
        currentPathCount=[[0 for i in range(NodeNum)] for j in range(NodeNum)]
    
        for i in range(NodeNum):
            for j in range(NodeNum):
                lastShortestDistance[i][j]=Graph[i][j]
                if (Graph[i][j]>0) and (Graph[i][j]<10):
                    lastPathCount[i][j]=1
                else:
                    lastPathCount[i][j]=0
                currentShortestDistance[i][j]=lastShortestDistance[i][j]
                currentPathCount[i][j]=lastPathCount[i][j]
    
        for k in range(NodeNum):
            for i in range(NodeNum):
                if (i==k):
                    continue
                for j in range(NodeNum):
                    if (j==k):
                        continue
                    if(lastShortestDistance[i][j]<lastShortestDistance[i][k]+lastShortestDistance[k][j]):
                        continue
                    if(lastShortestDistance[i][j]==lastShortestDistance[i][k]+lastShortestDistance[k][j]):
                        currentShortestDistance[i][j]=lastShortestDistance[i][j]
                        currentPathCount[i][j]=lastPathCount[i][j]+lastPathCount[i][k]*lastPathCount[k][j]
                    if(lastShortestDistance[i][j]>lastShortestDistance[i][k]+lastShortestDistance[k][j]):
                        currentShortestDistance[i][j]=lastShortestDistance[i][k]+lastShortestDistance[k][j]
                        currentPathCount[i][j]=lastPathCount[i][k]*lastPathCount[k][j]
    
            lastShortestDistance=currentShortestDistance
            lastPathCount=currentPathCount
    
        for i in range(NodeNum):
            for j in range(NodeNum):
                ShortestPath[i][j]=currentShortestDistance[i][j]
                PathCount[i][j]=currentPathCount[i][j]
    
        return None
    
    nodeNum=4
    graph=[[0,1,1,10],[1,0,10,10],[1,10,0,1],[10,10,1,0]]
    shortestPath=[[0 for i in range(nodeNum)] for j in range(nodeNum)]
    pathCount=[[0 for i in range(nodeNum)] for j in range(nodeNum)]
    
    Floyd(graph,shortestPath,pathCount)
    print(shortestPath)
    print(pathCount)
    展开全文
  • floyd算法(多源最短路径) python实现

    千次阅读 2019-06-26 20:28:13
    Floyd算法用来找每个点两两之间的最短距离(多源最短路径),是典型的动态规划 原理很简单: 一个点 i 到另一个点 j 的最短路径无非有两种: 直接到达( i --> j ) 通过走其他点(k1, k2 … kn),一个或多个点到达...

    Floyd(弗洛伊德)算法用来找每个点两两之间的最短距离(多源最短路径),是典型的动态规划

    原理很简单:
    一个点 i 到另一个点 j 的最短路径无非有两种:

    1. 直接到达( i --> j )
    2. 通过走其他点(k1, k2 … kn),一个或多个点到达( i --> k1–>k2–> … --> j )

    所以找最短路就直接 比较 1 和 2 哪条路径更短

    数据结构:邻接矩阵(n*n) graph, graph[ i ][ j ]表示 i --> j 的最短路径。
    初始化:一开始全设为无穷大,如果 i == j , graph[ i ][ j ] == 0,然后遍历所有图中的所有边 i --> j ,令 graph[ i ][ j ] = 边权

    要找到 i 到 j 的最短路径,我们需要 i 去经过另外的结点再走回 j(i --> k --> j),看和原路径(i --> j)谁更短,然后更新graph[ i ][ j ]。要得出这个结果就得每个结点都走一遍。

    这里作个演示。比如我们可以先只经过编号为 1 的结点,比较 i --> j 和 i --> 1–> j,哪条路小,然后更新 i --> j的最短路径
    graph[ i ][ j ] = min ( graph[ i ][ j ], graph[ i ][ 1 ] + graph[ 1 ][ j ] )

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

    同理经过其他点,比如编号为2的点

    for i in range(n):
    	for j in range(n):
    		graph[i][j] = min(graph[i][j], graph[i][2] + graph[2][j])
    

    最后我们每个点都要经过:

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

    是不是很简单。。。核心代码就只有4行代码。。。

    因为每次 i --> j 的路径都更新为最优的而且都被保存下来,所以后面的结点要通过这个结点去往别的结点,就能保证是最优的。

    例子:
    图片来自:https://www.cnblogs.com/wangyuliang/p/9216365.html
    这篇博客里面讲的更详细

    如果要打印路径,我们就需要用一个二维数组parents记录每个结点的父结点。在找最短路的时候,更新父结点。最后递归寻找父结点,回溯打印。

    import sys
    
    sys.setrecursionlimit(100000000)
    
    
    # 弗洛伊德算法
    def floyd():
        n = len(graph)
        for k in range(n):
            for i in range(n):
                for j in range(n):
                    if graph[i][k] + graph[k][j] < graph[i][j]:
                        graph[i][j] = graph[i][k] + graph[k][j]
                        parents[i][j] = parents[k][j]  # 更新父结点
    
    
    # 打印路径
    def print_path(i, j):
        if i != j:
            print_path(i, parents[i][j])
        print(j, end='-->')
    
    
    # Data [u, v, cost]
    datas = [
        [0, 1, 2],
        [0, 2, 6],
        [0, 3, 4],
        [1, 2, 3],
        [2, 0, 7],
        [2, 3, 1],
        [3, 0, 5],
        [3, 2, 12],
    ]
    
    n = 4
    
    # 无穷大
    inf = 9999999999
    
    # 构图
    graph = [[(lambda x: 0 if x[0] == x[1] else inf)([i, j]) for j in range(n)] for i in range(n)]
    parents = [[i] * n for i in range(4)]  # 关键地方,i-->j 的父结点初始化都为i
    for u, v, c in datas:
        graph[u][v] = c	# 因为是有向图,边权只赋给graph[u][v]
        #graph[v][u] = c # 如果是无向图,要加上这条。
    
    floyd()
    
    print('Costs:')
    for row in graph:
        for e in row:
            print('∞' if e == inf else e, end='\t')
        print()
    
    print('\nPath:')
    for i in range(n):
        for j in range(n):
            print('Path({}-->{}): '.format(i, j), end='')
            print_path(i, j)
            print(' cost:', graph[i][j])
    
    # 最终的graph
    # graph[i][j]表示i-->j的最短路径
    # 0	2	5	4
    # 9	0	3	4
    # 6	8	0	1
    # 5	7	10	0
    #
    # Path:
    # Path(0-->0): 0--> cost: 0
    # Path(0-->1): 0-->1--> cost: 2
    # Path(0-->2): 0-->1-->2--> cost: 5
    # Path(0-->3): 0-->3--> cost: 4
    # Path(1-->0): 1-->2-->3-->0--> cost: 9
    # Path(1-->1): 1--> cost: 0
    # Path(1-->2): 1-->2--> cost: 3
    # Path(1-->3): 1-->2-->3--> cost: 4
    # Path(2-->0): 2-->3-->0--> cost: 6
    # Path(2-->1): 2-->3-->0-->1--> cost: 8
    # Path(2-->2): 2--> cost: 0
    # Path(2-->3): 2-->3--> cost: 1
    # Path(3-->0): 3-->0--> cost: 5
    # Path(3-->1): 3-->0-->1--> cost: 7
    # Path(3-->2): 3-->0-->1-->2--> cost: 10
    # Path(3-->3): 3--> cost: 0
    
    展开全文
  • 弗洛伊德算法Python实现

    千次阅读 2018-10-05 20:22:34
    自己最近在学ML,开始使用Python,相比较与C与Java,Python的代码量更少,代码阅读起来也比较简单,所以打算用Python将以前看过的算法总结一次。这个系列不以难易程度递增更新,想起哪个算法就先更新哪一个。  在...
  • Python-Floyd算法(五行核心代码)

    千次阅读 2018-03-13 23:19:25
    一、前言 很早之前就想把之前看过的算法问题总结出来,现在出的书籍基本上都是以C、Java为基础的算法书籍,以Python为基础的算法书籍很少。自己最近在学ML,开始使用Python,相比较与C与Java,Python的代码量更少,...
  • 弗洛伊德算法-python

    千次阅读 2019-10-14 20:54:12
    3.Dijkstra(迪杰斯特拉)算法时间复杂度一般是o(n^2),Floyd算法时间复杂度是o(n^3),Dijkstra(迪杰斯特拉)算法比Floyd算法块。 4.Floyd算法属于动态规划,Dijkstra(迪杰斯特拉)算法属于贪心算法。 原文 ...
  • Floyd算法python实现

    2021-04-01 17:24:46
    def Floyd(map,start,end): points=len(map) A = map Path=[[_ for i in range(points)] for j in range(points)] for i in range(points): for j in range(points): if i!=j and map[i][j]!=_:
  • num): for k in range(node_num): #Floyd法 将行向量转置后与列相加,与原值相比后保留最小值 dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]) num+=1 #迭代n-1后退出循环 print('各个点间的最短路长为:') #输出...
  • Floyd算法是解决任意两点间的最短路径的一种算法,可以正确处理带权有向图或负权的最短路径问题 Floyd算法的基本思想: 1. 利用二维数组dist[i][j]记录当前vi到vj的最短路径长度,数组dist的初值等于图的带权邻接...
  • floyd算法完成最短路径的选择 题目:有如图A,B,C,D,E五个节点,试问从A到D的最短路径是多少步? 问题分析:从A到D,若用穷举法,有A-B-D, A-B-E-C-D,等,此时因为节点数少,用穷举法自然能够求出,若节点数...
  • 主要为大家详细介绍了基于Python实现迪杰斯特拉和弗洛伊德算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Python Floyd算法求最短路径

    千次阅读 2019-11-21 22:07:38
    floyd算法(多源最短路径) python实现 例题 求下图各节点最短路径 Floyd算法如下: from math import * import numpy as np #创建节点字典 set_nodes={"v1":0,"v2":1,"v3":2,"v4":3,"v5":4,"v6":5,"v7":6,"v8":7,"v9...
  • Python实现图的经典Dijkstra、Floyd算法

    千次阅读 2020-09-18 11:10:24
    1. 简介 对于最短路径算法的Dijkstra、Floyd算法: ...而Floyd算法针对的问题是求每对顶点之间的最短路径,相当于把Dijkstra算法执行了n遍(实际上并不是这样做),所以Floyd算法的时间复杂度为O(n3
  • 在各类产业智能化发展的21世纪中,无人驾驶技术作为IT产业与传统汽车紧密相结合的代表,得到了高速发展,无人驾驶的路径规划问题一直是其发展过程中的一个难关。
  • python Floyd算法

    2016-04-16 11:03:06
    python Floyd算法
  • from math import inf from binary_tree.PrioQueue import PrioQueue def dijkstra_shortest_paths(graph,v0): vnum = graph.vertex_num() assert 0 <= v0 < vnum # 第几个节点 paths = [None]*vnum ...
  • 之前的迪杰斯特拉算法求得是知道起始点,然后得出从起始点到剩下所有顶点的最短路径。时间复杂度为O(n2)O(n^2)O(n2)。那如果要求出每一对顶点之间的最短路径,首先想到的一个方法就是:每次以一个顶点为源点出发,...
  • python 无向图最短路径之floyd算法

    千次阅读 2019-04-30 17:36:47
    ... floyd算法:能够找到图中任意两个节点之间的最短路径,时间复杂度为O(n**3),其中n表示图中的节点数 算法思路: 假设当前的 通过floyd算法计算图中任意两个节点之间的...
  • 有向图最短路径floyd算法python实现

    千次阅读 2012-11-09 15:48:02
    Created on 2012-11-8 @author: Pandara ''' import sys def floyd(l, n): ''' l: l[i][j] = distace of i and j if in E else sys.maxint k: sum of point ''' d = l[:] route =
  • 2.根据最新的路线图hmap,运用最短路径算法Floyd-Warshall算法,求得任意两城市之间最短路径所必须经过的城市,放在path矩阵中(A矩阵存放对应的权值) 3.然后编写一个函数getRoutes(path,start,end),根据指定的...
  • 深度优先遍历,广度优先遍历,Dijkstra算法,Floyd算法,Prim算法,WelshPowell着色算法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,584
精华内容 633
关键字:

floyd算法python

python 订阅