python用动态规划求最短路径,最短路径步骤
用python实现最短路径的方法：1。Dijkstra算法：声明一个数组dis保存源点到每个顶点的最短距离；2.弗洛伊德算法：在有向图中寻找点与点之间的最短路径；3.SPFA算法：使用数组dis记录每个节点的最短路径估计值。
最短路径问题(python实现)
求解最短路径问题：(以下三种算法)
(1)迪杰斯特拉算法(Dijkstra algorithm)
(2)弗洛伊德算法(Floyd algorithm)
(3)SPFA算法
第一种算法：
Dijkstra算法
广度优先搜索是解决加权有向图或无向图的单源最短路径问题的一种贪婪策略。
算法的思想
声明一个数组dis来保存从源点到每个顶点的最短距离，声明一个集合来保存已经找到最短路径的顶点：t，
开始时，原点s的路径权重被赋值为0(dis[s]=0)。如果顶点S有一条可以直接到达的边(S，m)，设dis[m]为w(s，m)，
同时将所有其他顶点(S无法直接到达的)的路径长度设置为无穷大。开始时，集合t只有顶点s。
然后，从dis数组中选取最小值，这是从源点S到这个值对应的顶点的最短路径，把这个点加到T上，OK，那么一个顶点就完成了，
看新添加的顶点是否能到达其他顶点，以及通过顶点到其他点的路径长度是否比直接到源点的路径长度短。
如果是，则替换dis中这些顶点的值，然后从dis中找出最小值，重复上述动作，直到T包含图的所有顶点。第二种算法：
弗洛伊德算法
原则：
弗洛伊德算法(Floyd algorithm)是一种在有向图中寻找最短路径的算法。它是一种求解有向图中点与点之间最短路径的算法。
求负权有向图中的最短路径(但不能包含负权环)。
流程：
对于有向图中的每个节点X，对于通过该图的两个点A和B，
若有Dis(AX) Dis(XB) Dis(AB)，则令Dis(AB)=Dis(AX) Dis(XB)。
当所有的节点X都遍历完之后，就找到了AB的最短路径。
示例1:
#-*-编码：utf-8-*-
#python实现了弗洛伊德算法
N=4
_=float(inf)# infinity
graph=[[0，2，6，4]，[_，0，3，_]，[7，_，0，1]，[5，_，12，0]]
Path=[[-1，-1，-1，-1]，[-1，-1，-1]，[-1，-1，-1]] #记录路径，最后
Defback_path(path，I，j):#递归回溯
而(-1！=path[i][j]):
back_path(path，I，path[i][j])
back_path(path，path[i][j]，j)
printpath[i][j]，14
返回；
返回；
打印“图表：\n”，图表
福金范围(北):
第：号
福金
bsp;range(N):
ifgraph[i][j]>graph[i][k]+graph[k][j]:
graph[i][j]=graph[i][k]+graph[k][j]
path[i][j]=k
print"Shortestdistance:\n",graph
print"Path:\n",path
print"Pointspass-by:"
foriinrange(N):
forjinrange(N):
print"%d->%d:"%(i,j),
back_path(path,i,j)
print"\n",示例二：
#!usr/bin/envpython#encoding:utf-8示例三：'''
功能：使用floyd算法求最短路径距离
'''
importrandom
importtime
defrandom_matrix_genetor(vex_num=10):
'''
随机图顶点矩阵生成器
输入：顶点个数，即矩阵维数
'''
data_matrix=[]
foriinrange(vex_num):
one_list=[]
forjinrange(vex_num):
one_list.append(random.randint(1,100))
data_matrix.append(one_list)
returndata_matrixdeffloyd(data_matrix):
'''
输入：原数据矩阵，即：一个二维数组
输出：顶点间距离'''
dist_matrix=[]
path_matrix=[]
vex_num=len(data_matrix)
forhinrange(vex_num):
one_list=['N']*vex_num
path_matrix.append(one_list)
dist_matrix.append(one_list)
foriinrange(vex_num):
forjinrange(vex_num):
dist_matrix=data_matrix
path_matrix[i][j]=j
forkinrange(vex_num):
foriinrange(vex_num):
forjinrange(vex_num):
ifdist_matrix[i][k]=='N'ordist_matrix[k][j]=='N':
temp='N'
else:
temp=dist_matrix[i][k]+dist_matrix[k][j]
ifdist_matrix[i][j]>temp:
dist_matrix[i][j]=temp
path_matrix[i][j]=path_matrix[i][k]
returndist_matrix,path_matrixdefmain_test_func(vex_num=10):
'''
主测试函数
'''
data_matrix=random_matrix_genetor(vex_num)
dist_matrix,path_matrix=floyd(data_matrix)
foriinrange(vex_num):
forjinrange(vex_num):
print'顶点'+str(i)+'----->'+'顶点'+str(j)+'最小距离为:',dist_matrix[i][j]
if__name__=='__main__':
data_matrix=[['N',1,'N',4],[1,'N',2,'N'],['N',2,'N',3],[4,'N',3,'N']]
dist_matrix,path_matrix=floyd(data_matrix)
printdist_matrix
printpath_matrix
time_list=[]
print'------------------------------节点数为10测试情况------------------------------------'
start_time0=time.time()
main_test_func(10)
end_time0=time.time()
t1=end_time0-start_time0
time_list.append(t1)
print'节点数为10时耗时为：',t1
print'------------------------------节点数为100测试情况------------------------------------'
start_time1=time.time()
main_test_func(100)
end_time1=time.time()
t2=end_time1-start_time1
time_list.append(t2)
print'节点数为100时耗时为：',t2
print'------------------------------节点数为1000测试情况------------------------------------'
start_time1=time.time()
main_test_func(1000)
end_time1=time.time()
t3=end_time1-start_time1
time_list.append(t3)
print'节点数为100时耗时为：',t3
print'--------------------------------------时间消耗情况为：--------------------------------'
forone_timeintime_list:
printone_time
importnumpyasnp第三种算法：Max=100
v_len=4
edge=np.mat([[0,1,Max,4],[Max,0,9,2],[3,5,0,8],[Max,Max,6,0]])
A=edge[:]
path=np.zeros((v_len,v_len))
defFolyd():
foriinrange(v_len):
forjinrange(v_len):
if(edge[i,j]!=Maxandedge[i,j]!=0):
path[i][j]=i
print'init:'
printA,'\n',path
forainrange(v_len):
forbinrange(v_len):
forcinrange(v_len):
if(A[b,a]+A[a,c]<A[b,c]):
A[b,c]=A[b,a]+A[a,c]
path[b][c]=path[a][c]
print'result:'
printA,'\n',path
if__name__=="__main__":
Folyd()
SPFA算法是求解单源最短路径问题的一种算法，由理查德·贝尔曼（Richard Bellman） 和 莱斯特·福特 创立的。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore 也为这个算法的发展做出了贡献。它的原理是对图进行V-1次松弛操作，得到所有可能的最短路径。
其优于迪科斯彻算法的方面是边的权值可以为负数、实现简单，缺点是时间复杂度过高，高达 O(VE)。但算法可以进行若干种优化，提高了效率。
思路：
我们用数组dis记录每个结点的最短路径估计值，用邻接表或邻接矩阵来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。
推荐课程：聚类算法深度解析(黑马程序员)
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。