Python數模筆記-NetworkX(2)最短路徑

youcans發表於2021-05-18

1、最短路徑問題的常用演算法

最短路徑問題是圖論研究中的經典演算法問題,用於計算圖中一個頂點到另一個頂點的最短路徑。

1.1 最短路徑長度與最短加權路徑長度

在日常生活中,最短路徑長度與最短路徑距離好像並沒什麼區別。但在具體的圖論問題中卻可能是不同的概念和問題,經常會被混淆。

圖論中有無權圖和有權圖,無權圖中的邊沒有權,賦權圖的邊帶有權,可以表示距離、時間、費用或其它指標。在問題文字描述中,往往並不直接指出是無權圖還是有權圖,這時就要注意最短路徑與最短加權路徑的區別。路徑長度是把每個頂點到相鄰頂點的長度記為 1,而不是指這兩個頂點之間道路的距離——兩個頂點之間的道路距離是連線邊的權(weight)。通俗地說,路徑長度可以認為是飛行棋的步數,或者公交站點的站數,相鄰頂點之間為一步,相隔幾個頂點就是幾站。路徑長度是從路徑起點到終點的步數,計算最短路徑是要計算從起點到終點步數最小的路徑。

如果問題不涉及頂點之間的距離,要求從起點到終點的最短路徑及對應的最短長度,是指從這條路線從起點到終點有幾站,在圖論中稱為最短路徑長度。但是,如果問題給出頂點之間的道路長度或距離,姑且稱為各路段的距離,要求從起點到終點的最短路徑及對應的最短距離,顯然並不是在找經過最少步數的路徑,而是在找路徑中各路段的距離之和最小的路徑,在圖論中稱為最短加權路徑長度——這裡權重是路段距離。

=== 關注 Youcans 原創系列(https://www.cnblogs.com/youcans/)

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 最短路徑演算法的選擇

  1. 需要求解任意兩個節點之間的最短距離,使用 Floyd 演算法;
  2. 只要求解單源最短路徑問題,有負權邊時使用 Bellman-Ford 演算法,沒有負權邊時使用 Dijkstra 演算法;
  3. 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 無權圖最短路徑演算法

函式 功能
single_source_shortest_path(G, source[,cutoff]) 計算從源到所有可達節點的最短路徑
single_source_shortest_path_length(G,source) 計算從源到所有可達節點的最短路徑長度
single_target_shortest_path(G, target[,cutoff]) 計算從所有可達節點到目標的最短路徑
single_target_shortest_path_length(G,target) 計算從所有可達節點到目標的最短路徑長度
all_pairs_shortest_path(G[, cutoff]) 計算所有節點之間的最短路徑
all_pairs_shortest_path_length(G[, cutoff]) 計算所有節點之間的最短路徑長度

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)

# 關注 Youcans 原創系列(https://www.cnblogs.com/youcans/)
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
Python數模筆記-NetworkX(2)最短路徑

3.4 程式說明

  1. 圖的輸入。本例為稀疏的有權無向圖,使用 G.add_weighted_edges_from() 函式可以使用列表向圖中新增多條賦權邊,每個賦權邊以元組 (node1,node2,weight) 表示。
  2. 圖的繪製。使用nx.draw()繪圖時,預設的節點位置可能並不理想,nx.spring_layout() 使用 Fruchterman-Reingold 力定向演算法定位節點。
  3. 繪製邊的屬性。使用 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))

# # 關注 Youcans 原創系列(https://www.cnblogs.com/youcans/)
# 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
Python數模筆記-NetworkX(2)最短路徑

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() 返回最短加權路徑長度,本例中權重為票價,最短加權路徑長度即為兩點間最便宜的直航或中轉的機票票價。
    通過本案例,可以直觀地理解最短路徑長度與最短加權路徑長度的區別。

關注 Youcans 原創系列(https://www.cnblogs.com/youcans/)===

版權說明:

本文內容及例程為作者原創,並非轉載書籍或網路內容。
本文中案例問題來自:
1、司守奎、孫兆亮,數學建模演算法與應用(第2版),國防工業出版社。

YouCans 原創作品
Copyright 2021 YouCans, XUPT
Crated:2021-05-18

相關文章