Python数模笔记-NetworkX（2）最短路径-FlyAI

Python数模笔记-NetworkX（2）最短路径

Python3

最后更新 2021-06-01 15:09 阅读 7983

最后更新 2021-06-01 15:09

阅读 7983

Python3

**1、最短路径问题的常用算法**

最短路径问题是图论研究中的经典算法问题，用于计算图中一个顶点到另一个顶点的最短路径。

**1.1 最短路径长度与最短加权路径长度**

在日常生活中，最短路径长度与最短路径距离好像并没什么区别。但在具体的图论问题中却可能是不同的概念和问题，经常会被混淆。

图论中有无权图和有权图，无权图中的边没有权，赋权图的边带有权，可以表示距离、时间、费用或其它指标。在问题文字描述中，往往并不直接指出是无权图还是有权图，这时就要注意最短路径与最短加权路径的区别。路径长度是把每个顶点到相邻顶点的长度记为 1，而不是指这两个顶点之间道路的距离——两个顶点之间的道路距离是连接边的权（weight）。通俗地说，路径长度可以认为是飞行棋的步数，或者公交站点的站数，相邻顶点之间为一步，相隔几个顶点就是几站。路径长度是从路径起点到终点的步数，计算最短路径是要计算从起点到终点步数最小的路径。

如果问题不涉及顶点之间的距离，要求从起点到终点的最短路径及对应的最短长度，是指从这条路线从起点到终点有几站，在图论中称为最短路径长度。但是，如果问题给出顶点之间的道路长度或距离，姑且称为各路段的距离，要求从起点到终点的最短路径及对应的最短距离，显然并不是在找经过最少步数的路径，而是在找路径中各路段的距离之和最小的路径，在图论中称为最短加权路径长度——这里权重是路段距离。

**1.2 最短路径的常用算法**

求解最短路径长度的常用算法是 Dijkstra 算法、Bellman-Ford 算法和Floyd 算法，另外还有启发式算法 A*。

- Dijkstra 算法

Dijkstra 算法用于计算有权图中最短路径问题 。该算法从起点开始，采用贪心法策略，每次遍历到起点距离最近且未访问过的顶点的邻接节点， 直到扩展到终点为止。

Dijkstra 算法的时间复杂度为 O(n^2)。如果边数远小于 n^2，可以用堆结构将复杂度降为O((m+n)log(n))。

Dijkstar算法不能处理负权边。

- Bellman-Ford 算法

Bellman-Ford 算法用于求解单源最短路径问题。算法原理是对图进行 V-1次松弛操作，得到所有可能的最短路径。

Bellman-Ford 算法的时间复杂度高达 O(V*E)，V、E 分别是顶点和边的数量。

Bellman-Ford 算法可以处理负权边。其基本操作“拓展”是在深度上搜索，而“松弛”操作则在广度上搜索，因此可以对负权边进行操作而不影响结果。

- Floyd 算法

Floyd 算法又称插点法，利用动态规划思想求解有权图中多源点之间最短路径问题。算法从图的带权邻接矩阵开始，递归地进行 n 次更新得到图的距离矩阵，进而可以得到最短路径节点矩阵。

Floyd 算法的时间复杂度为 O(n^3)，空间复杂度为 O(n^2)。算法时间复杂度较高，不适合计算大量数据。Floyd 算法的优点是可以一次性求解任意两个节点之间的最短距离，对于稠密图的效率高于执行 V 次 Dijkstra算法。

Floyd 算法可以处理负权边。

- A* 算法

A*算法是一种静态路网中求解最短路径最有效的直接搜索方法。

A*算法是启发式算法，采用最好优先（Best-first）搜索策略，基于估价函数对每个搜索位置的评估结果，猜测最好的位置优先进行搜索。

A*算法极大地减少了低质量的搜索路径，因而搜索效率很高，比传统的路径规划算法实时性更高、灵活性更强；但是，A*算法找到的是相对最优路径，不是绝对的最短路径，适合大规模、实时性高的问题。

- 1.3 最短路径算法的选择

需要求解任意两个节点之间的最短距离，使用 Floyd 算法；
只要求解单源最短路径问题，有负权边时使用 Bellman-Ford 算法，没有负权边时使用 Dijkstra 算法；
A*算法找到的是相对最优路径，适合大规模、实时性高的问题。

**2、NetworkX 中的最短路径算法**

- 2.1 无向图和有向图的最短路径求解函数

|  函数 | 功能  |
| ------------ | ------------ |
| shortest_path(G[, source, target, weight,...])   | 计算图中的最短路径  |
| all_shortest_paths(G, source, target[,...])  |  计算图中所有最短的简单路径 |
|  shortest_path_length(G[, source, target, ...]) | 计算图中的最短路径长度  |
|  average_shortest_path_length(G[, weight, method]) |  计算平均最短路径长度 |

**2.2 无权图最短路径算法**

**2.3 有权图最短路径算法**

|函数|功能|
|------------|-------------|
|dijkstra_path(G, source, target[, weight])|计算从源到目标的最短加权路径|
|dijkstra_path_length(G, source, target[,weight])|计算从源到目标的最短加权路径长度|
|all_pairs_dijkstra_path(G[, cutoff, weight])|计算所有节点之间的最短加权路径|
|all_pairs_dijkstra_path_length(G[, cutoff,... ])|计算所有节点之间的最短加权路径长度|
|bellman_ford_path(G, source, target[, weight])|计算从源到目标的最短路径|
|bellman_ford_path_length(G, source, target)|计算从源到目标的最短路径长度|
|all_pairs_bellman_ford_path(G[, weight])|计算所有节点之间的最短路径|
|all_pairs_bellman_ford_path_length(G[,weight])|计算所有节点之间的最短路径长度|
|floyd_warshall(G[, weight])|用 Floyd 法计算所有节点之间的最短路径长度|
|floyd_warshall_numpy(G[, nodelist, weight])|用 Floyd 法计算所有指定节点之间的最短路径长度|

**3、NetworkX 中的 Dijkstra 算法**

NetworkX 中关于 Dijkstra 算法提供了 13 个函数，很多函数的功能是重叠的。这里只介绍最基本的函数 dijkstra_path() 和 dijkstra_path_length()。

**3.1 dijkstra_path() 和 dijkstra_path_length() 使用说明**

dijkstra_path() 用于计算从源到目标的最短加权路径，dijkstra_path_length() 用于计算从源到目标的最短加权路径长度。

dijkstra_path(G, source, target, weight='weight')

dijkstra_path_length(G, source, target, weight='weight')

主要参数：

- G(NetworkX graph)：图。
- source (node)：起点。
- target (node)：终点。

weight (string or function)：参数为字符串(string)时，按该字符串查找边的属性作为权重；如果该字符串对应的边属性不存在，则权重置为1；参数为函数时，边的权重是函数的返回值。
返回值：
dijkstra_path() 的返回值是最短加权路径中的节点列表，数据类型为list。
dijkstra_path_length() 的返回值是最短加权路径的长度（路径中的边的权重之和），数据类型为 number。

**3.2 dijkstra_path() 算法使用例程**

本案例问题来自：司守奎、孙兆亮，数学建模算法与应用（第2版），P43，例4.3，国防工业出版社。

例4.3：无向图的最短路问题。已知如图的有权无向图，求顶点 v1 到 顶点 v11 的最短路径。
```
# networkX_E2.py
# Demo of shortest path with NetworkX
# Copyright 2021 YouCans, XUPT
# Crated：2021-05-18

import matplotlib.pyplot as plt # 导入 Matplotlib 工具包
import networkx as nx  # 导入 NetworkX 工具包

# 问题 2：无向图的最短路问题（司守奎，数学建模算法与应用，P43，例4.3）
G2 = nx.Graph()  # 创建：空的 无向图
G2.add_weighted_edges_from([(1,2,2),(1,3,8),(1,4,1),
                            (2,3,6),(2,5,1),
                            (3,4,7),(3,5,5),(3,6,1),(3,7,2),
                            (4,7,9),
                            (5,6,3),(5,8,2),(5,9,9),
                            (6,7,4),(6,9,6),
                            (7,9,3),(7,10,1),
                            (8,9,7),(8,11,9),
                            (9,10,1),(9,11,2),
                            (10,11,4)])  # 向图中添加多条赋权边: (node1,node2,weight)
# 两个指定顶点之间的最短加权路径
minWPath_v1_v11 = nx.dijkstra_path(G2, source=1, target=11)  # 顶点 0 到 顶点 3 的最短加权路径
print("顶点 v1 到 顶点 v11 的最短加权路径: ", minWPath_v1_v11)
# 两个指定顶点之间的最短加权路径的长度
lMinWPath_v1_v11 = nx.dijkstra_path_length(G2, source=1, target=11)  #最短加权路径长度
print("顶点 v1 到 顶点 v11 的最短加权路径长度: ", lMinWPath_v1_v11)

pos = nx.spring_layout(G2)  # 用 FR算法排列节点
nx.draw(G2, pos, with_labels=True, alpha=0.5)
labels = nx.get_edge_attributes(G2,'weight')
nx.draw_networkx_edge_labels(G2, pos, edge_labels = labels)
plt.show()
```
**3.3 程序运行结果**
```
顶点 v1 到 顶点 v11 的最短加权路径:  [1, 2, 5, 6, 3, 7, 10, 9, 11]
顶点 v1 到 顶点 v11 的最短加权路径长度:  13
```
![](https://img2020.cnblogs.com/blog/2305037/202105/2305037-20210518201321801-896787123.png)
**3.4 程序说明**

图的输入。本例为稀疏的有权无向图，使用 G.add_weighted_edges_from() 函数可以使用列表向图中添加多条赋权边，每个赋权边以元组 (node1,node2,weight) 表示。
图的绘制。使用nx.draw()绘图时，默认的节点位置可能并不理想，nx.spring_layout() 使用 Fruchterman-Reingold 力定向算法定位节点。
绘制边的属性。使用 nx.draw_networkx_edge_labels() 可以绘制边的属性，例程中选择显示权重属性。

**4、NetworkX 中的 Bellman-Ford 算法**

NetworkX 中关于 Bellman-Ford 算法提供了 13 个函数，很多函数的功能是重叠的。这里只介绍最基本的函数 bellman_ford_path() 和 bellman_ford_path_length()。

**4.1 bellman_ford_path() 和 bellman_ford_path_length() 使用说明**

bellman_ford_path() 用于计算从源到目标的最短加权路径，bellman_ford_path_length() 用于计算从源到目标的最短加权路径长度。

bellman_ford_path(G, source, target, weight='weight')

bellman_ford_path_length(G, source, target, weight='weight')

主要参数：

- G(NetworkX graph)：图。
- source (node)：起点。
- target (node)：终点。
- weight (string)：按字符串查找边的属性作为权重。默认值为权重 'weight'。

返回值：

bellman_ford_path() 的返回值是最短加权路径中的节点列表，数据类型为list。
bellman_ford_path_length() 的返回值是最短加权路径的长度（路径中的边的权重之和），数据类型为 number。

**4.2 bellman_ford_path() 算法使用例程**

本案例问题来自：司守奎、孙兆亮，数学建模算法与应用（第2版），P41，例4.1，国防工业出版社。

例4.1：城市间机票价格问题。已知 6个城市之间的机票票价如矩阵所示（无穷大表示没有直航），求城市 c1 到其它城市 c2...c6 的票价最便宜的路径及票价。
```
# networkX_E1.py
# Demo of shortest path with NetworkX
# Copyright 2021 YouCans, XUPT
# Crated：2021-05-18

import pandas as pd
import matplotlib.pyplot as plt # 导入 Matplotlib 工具包
import networkx as nx  # 导入 NetworkX 工具包

# 问题 1：城市间机票价格问题（司守奎，数学建模算法与应用，P41，例4.1）
# # 从Pandas数据格式（顶点邻接矩阵）创建 NetworkX 图
# # from_pandas_adjacency(df, create_using=None) # 邻接矩阵，n行*n列，矩阵数据表示权重
dfAdj = pd.DataFrame([[0, 50, 0, 40, 25, 10],  # 0 表示不邻接，
                      [50, 0, 15, 20, 0, 25],
                      [0, 15, 0, 10, 20, 0],
                      [40, 20, 10, 0, 10, 25],
                      [25, 0, 20, 10, 0 ,55],
                      [10, 25, 0, 25, 55, 0]])
G1 = nx.from_pandas_adjacency(dfAdj)  # 由 pandas 顶点邻接矩阵 创建 NetworkX 图

# 计算最短路径：注意最短路径与最短加权路径的不同
# 两个指定顶点之间的最短路径
minPath03 = nx.shortest_path(G1, source=0, target=3)  # 顶点 0 到 顶点 3 的最短路径
lMinPath03 = nx.shortest_path_length(G1, source=0, target=3)  #最短路径长度
print("顶点 0 到 3 的最短路径为：{}，最短路径长度为：{}".format(minPath03, lMinPath03))
# 两个指定顶点之间的最短加权路径
minWPath03 = nx.bellman_ford_path(G1, source=0, target=3)  # 顶点 0 到 顶点 3 的最短加权路径
# 两个指定顶点之间的最短加权路径的长度
lMinWPath03 = nx.bellman_ford_path_length(G1, source=0, target=3)  #最短加权路径长度
print("顶点 0 到 3 的最短加权路径为：{}，最短加权路径长度为：{}".format(minWPath03, lMinWPath03))

for i in range(1,6):
    minWPath0 = nx.dijkstra_path(G1, source=0, target=i)  # 顶点 0 到其它顶点的最短加权路径
    lMinPath0 = nx.dijkstra_path_length(G1, source=0, target=i)  #最短加权路径长度
    print("城市 0 到 城市 {} 机票票价最低的路线为: {}，票价总和为：{}".format(i, minWPath0, lMinPath0))

# nx.draw_networkx(G1) # 默认带边框，顶点标签
nx.draw(G1, with_labels=True, layout=nx.spring_layout(G1))
plt.show()
```
**4.3 程序运行结果**
```
顶点 0 到 3 的最短路径为：[0, 3]，最短路径长度为：1
顶点 0 到 3 的最短加权路径为：[0, 4, 3]，最短加权路径长度为：35
城市 0 到 城市 1 机票票价最低的路线为: [0, 5, 1]，票价总和为：35
城市 0 到 城市 2 机票票价最低的路线为: [0, 4, 2]，票价总和为：45
城市 0 到 城市 3 机票票价最低的路线为: [0, 5, 3]，票价总和为：35
城市 0 到 城市 4 机票票价最低的路线为: [0, 4]，票价总和为：25
城市 0 到 城市 5 机票票价最低的路线为: [0, 5]，票价总和为：10
```
**4.4 程序说明**

1. 图的输入。使用 pandas 中 DataFrame 读取数据文件非常方便，本例中以 pandas 输入顶点邻接矩阵，使用 nx.from_pandas_adjacency(dfAdj) 转换为 NetworkX 的图。

2. 邻接矩阵。邻接矩阵 dfAdj (i,j) 的值表示连接顶点 i、j 的边的权值， i、j 不相邻 dfAdj (i,j) =0， 本例中表示没有直航。

3. 最短路径与最短路径长度。nx.shortest_path() 返回最短路径。nx.shortest_path_length() 返回最短路径长度，本例中可以理解为从起点到终点的乘机次数，1 表示直航，2 表示中转一次。

4. 最短加权路径长度。nx.bellman_ford_path_length() 返回最短加权路径长度，本例中权重为票价，最短加权路径长度即为两点间最便宜的直航或中转的机票票价。

通过本案例，可以直观地理解最短路径长度与最短加权路径长度的区别。

版权说明：
本文内容及例程为作者原创，并非转载书籍或网络内容。
本文中案例问题来自：
NetworkX 官网介绍：https://networkx.org/documentation/stable/

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可，转载请附上原文出处链接和本声明。
本文链接地址：https://flyai.com/article/artfd2570e423665ccbf7f9929c?type=e

讨论

500字

表情

发送

删除确认

是否删除该条评论？

取消删除