动态规划求最短路径（Floyd算法）

动态规划求最短路径（Floyd算法）

问题概述

​ 在一无负权环的图中，给定起点startVertex和重点endVertex，求两点之间最短路径path的长度length。

大致思路

在此之前，我们已经学会了使用Dijkstra算法（一种贪心算法）来解决最短路径问题，然而在动态规划的框架下我们需要将问题“逐步解决”。

1. 假设我们我们已经得知，在允许途径v1,v2,v3…vn“中转”的前提下，各起点至各终点最短路径的长度。
2. 在1的基础上，继续求解在允许途径v1,v2,v3…vn+1“中转”的前提下，各起点至各终点最短路径的长度。

实现方式

​ 我们使用距离矩阵来记录这些长度。由上可知，我们拿到的第一个矩阵应当是该图的邻接矩阵，其中不相邻的两点对应位置应填上正无穷。并不断地增加“中转点”的范围，不断地对这个矩阵进行更新。当“中转点”集合等于点的全集时，我们就得到了记录从各点到各点的最短路径长。

​ 更新操作：

​ 当我们把在矩阵中对应索引为k的点新加入“中转点”集合时，需对该矩阵的每一个点进行以下操作：

for i in range(matrixa.shape[0]):
    for j in range(matrixa.shape[1]):
        if matrixa[i][j]>matrixa[i][k]+matrixa[j][k]:
            matrixa[i][j]=matrixa[i][k]+matrixa[j][k]

​

​ 通过三层循环，我们就可以实现这个算法。

路径的复现

​ 如上所述，该算法的时间复杂度为O(n^3),随着计算的推进，路径可能会有极大的变化，所以每次发现一条新的最短路径就将其单独保存很明显是不现实的。

​ 下面引入一个命题：

​ 已知点sVer至eVer的最短路径path0经过mVer。那么在这一路径中由自sVer至mVer的最短路径和自mVer至eVer的最短路径拼接而成。

​ 该命题的证明也很简单，如果两段路径不是各自的最短路径，那么两段路径就可以找出更短的，进而可得当前所谓的自sVer至eVer的“最短路径”并不最短。

​ 在上述命题已然成立的情况下，我们只需要得到自sVer至eVer最短路径中的某个mVer即可使用分治算法复原出整条路径。

复现路径实现

路径的记录

def findShortestPath(self,start,end):
        if end==start:
            return str(start)
        if self.path[start][end]==start:
            return str(start)+'->'+str(end)
        else:
            middle=self.path[start][end]
            return self.findShortestPath(start,middle)[:-1]+self.findShortestPath(middle,end)

总体而言，就是当邻接矩阵matrixa需要被k更新时，matrixb相同位置上记录为k。

需要注意的是，在初始化matrixm时，要将在matrixa相同位置上不为正无穷的位置设为对应的起点。即ver1与ver2直接相邻，则matrix[ver1][ver2]=ver1，其余位置一律设为None，表示尚无通路。

路径的复现

def showPath(ver1,ver2):
    if ver1==ver2:
        
    ver3=matrixm[ver1][ver2]
    if ver3==ver1:
        return str(ver1)+'->'+str(ver2)
    else:
        return merge(showPath(ver1,ver3),showPath(ver3,ver2))
def merge(path1,path2):
    path3=path1[:-1]+path2
    return path3

代码实现

graph.py

class graph:
    def __init__(self,size):

        self.size=size
        self.paths=[]
    #添加新边
    def adddge(self,start,end,weight):
        self.paths.append((start,end,weight))
    
    def addEdges(self,paths):
        self.paths.extend(paths)
    def floyd(self):
        #记录两点之间最短路径的长度
        self.dis = None
        #记录连点之间最短路径的某个点
        self.path = None
        #用'M'表示距离无穷大
        self.dis=[['M' for i in range(self.size)] for j in range(self.size)]
        #用'N'表示两点不连通
        self.path = [['N' for i in range(self.size)] for j in range(self.size)]
        for i in range(self.size):
            self.dis[i][i]=0
            self.path[i][i]=i
        for i in self.paths:
            self.dis[i[0]][i[1]]=i[2]
            self.path[i[0]][i[1]]=i[0]
        for k in range(self.size):
            for i in range(self.size):
                for j in range(self.size):
                    if( self.dis[i][k]!='M' and self.dis[k][j]!='M'):
                        if(self.dis[i][j]=='M' or self.dis[i][j]>self.dis[i][k]+self.dis[k][j]):
                            self.dis[i][j]=self.dis[i][k]+self.dis[k][j]
                            self.path[i][j]=k
        for i in self.dis:
            print(i)
        print('\n\n\n\n')
        for i in self.path:
            print(i)
    def findShortestPath(self,start,end):
        if end==start:
            return str(start)
        if self.path[start][end]==start:
            return str(start)+'->'+str(end)
        else:
            middle=self.path[start][end]
            return self.findShortestPath(start,middle)[:-1]+self.findShortestPath(middle,end)

测试

测试用图

要求得到点0到点3的最短路径。

我们可以根据这张图，直观的看到自0到3的最短路径为“0->2->4->3”

测试的代码实现

test.py

from graph import *
obj=graph(5)
obj.addPath(0,1,6)
obj.addPath(0,2,4)
obj.addPath(0,3,11)
obj.addPath(1,3,1)
obj.addPath(2,3,6)
obj.addPath(2,4,1)
obj.addPath(4,3,1)
obj.floyd()
print(obj.findShortestPath(0,3))

结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GdDQKlvM-1610545294430)(动态规划求最短路径（Floyd算法）.assets/测试结果.PNG)]

,1)
obj.addPath(2,3,6)
obj.addPath(2,4,1)
obj.addPath(4,3,1)
obj.floyd()
print(obj.findShortestPath(0,3))

结果

![在这里插入图片描述](https://img-blog.csdnimg.cn/2021011321421131.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzgyNTY3NQ==,size_16,color_FFFFFF,t_70#pic_center)


由上可得，我们的实现是成功的。