Python SciPy csgraph.maximum_flow用法及代碼示例

本文簡要介紹 python 語言中 scipy.sparse.csgraph.maximum_flow 的用法。

用法:

scipy.sparse.csgraph.maximum_flow(csgraph, source, sink)#

最大化圖中兩個頂點之間的流。

參數 ：：

csgraph： csr_matrix

表示有向圖的方陣，其第 (i, j) 項是一個整數，表示頂點 i 和 j 之間的邊的容量。

source： int

流從中流出的源頂點。

sink： int

流流向的匯頂點。

method: {‘edmonds_karp’, ‘dinic’}, optional：

用於計算最大流量的方法/算法。支持以下方法，

• ‘edmonds_karp’: Edmonds Karp algorithm in [1].

• ‘dinic’: Dinic’s algorithm in [4].

默認為‘dinic’。

返回 ：：

res： MaximumFlowResult

由 MaximumFlowResult 表示的最大流，包括 flow_value 中的流值和 flow 中的流圖。

拋出 ：：

TypeError:：

如果輸入圖不是 CSR 格式。

ValueError:：

如果容量值不是整數，或者源或接收器超出範圍。

注意：

這解決了給定有向加權圖上的最大流問題：流與每條邊相關聯的值，也稱為流，小於邊的容量，因此對於每個頂點(除了源頂點和匯頂點) ，總流入流量等於總流出流量。流的值是離開源頂點的所有邊的流的總和，最大流問題包括找到值最大的流。

根據max-flow min-cut定理，流的最大值也是最小割中邊的總權重。

為了解決這個問題，我們提供了Edmonds-Karp [1] 和 Dinic 算法 [4]。兩種算法的實現都力求利用稀疏性。前者的時間複雜度為\(O(|V|\,|E|^2)\)，其空間複雜度為\(O(|E|)\)。後者通過構建級別圖並在其中找到阻塞流來實現其性能。它的時間複雜度是\(O(|V|^2\,|E|)\)，它的空間複雜度是\(O(|E|)\)。

最大流量問題通常用實值容量來定義，但我們要求所有容量都是不可分割的，以確保收斂。在處理有理容量或某些固定 \(x \in \mathbb{R}\) 屬於 \(x\mathbb{Q}\) 的容量時，可以通過相應地縮放所有容量來將問題簡化為整數情況。

解決 maximum-flow 問題可用於例如計算機視覺中的圖割優化 [3]。

參考：

[1] (1,2)

Edmonds, J. 和 Karp, R. M. 網絡流問題算法效率的理論改進。 1972. ACM 雜誌。 19 (2): 第 248-264 頁

[2]

Cormen, T. H. 和 Leiserson, C. E. 以及 Rivest, R. L. 和 Stein C. 算法導論。第二版。 2001. 麻省理工學院出版社。

[3]

https://en.wikipedia.org/wiki/Graph_cuts_in_computer_vision

[4] (1,2)

Dinic, Efim A. 用功率估計解決網絡中最大流量問題的算法。在蘇聯數學。多克拉迪，第一卷。 11，第 1277-1280 頁。 1970 年。

例子：

也許最簡單的流問題是隻有兩個頂點的圖，其邊從源 (0) 到匯 (1)：

(0) --5--> (1)

這裏，最大流量就是邊的容量：

>>> import numpy as np
>>> from scipy.sparse import csr_matrix
>>> from scipy.sparse.csgraph import maximum_flow
>>> graph = csr_matrix([[0, 5], [0, 0]])
>>> maximum_flow(graph, 0, 1).flow_value
5
>>> maximum_flow(graph, 0, 1, method='edmonds_karp').flow_value
5

另一方麵，如果源和接收器之間存在瓶頸，則可以減少最大流量：

(0) --5--> (1) --3--> (2)

>>> graph = csr_matrix([[0, 5, 0], [0, 0, 3], [0, 0, 0]])
>>> maximum_flow(graph, 0, 2).flow_value
3

[2] 的第 26.1 章給出了一個不那麽簡單的例子：

>>> graph = csr_matrix([[0, 16, 13,  0,  0,  0],
...                     [0,  0, 10, 12,  0,  0],
...                     [0,  4,  0,  0, 14,  0],
...                     [0,  0,  9,  0,  0, 20],
...                     [0,  0,  0,  7,  0,  4],
...                     [0,  0,  0,  0,  0,  0]])
>>> maximum_flow(graph, 0, 5).flow_value
23

可以將在二分圖中找到最大匹配的問題簡化為最大流問題：讓\(G = ((U, V), E)\) 為二分圖。然後，向圖中添加一個源頂點，該頂點與 \(U\) 中的每個頂點的邊，以及一個與 \(V\) 中每個頂點的邊的匯頂點。最後，給結果圖中的每條邊賦予 1 的容量。然後，新圖中的最大流給出原始圖中的最大匹配，該匹配由 \(E\) 中流為正的邊組成。

假設邊由CSR格式的\(\lvert U \rvert \times \lvert V \rvert\)矩陣表示，如果從\(i \in U\)到\(j \in V\)有邊，則其\((i, j)\)'th entry為1，否則為0；也就是說，輸入是 maximum_bipartite_matching 所需的形式。然後上麵構造的圖的 CSR 表示包含這個矩陣作為一個塊。這是一個例子：

>>> graph = csr_matrix([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 1, 0]])
>>> print(graph.toarray())
[[0 1 0 1]
 [1 0 1 0]
 [0 1 1 0]]
>>> i, j = graph.shape
>>> n = graph.nnz
>>> indptr = np.concatenate([[0],
...                          graph.indptr + i,
...                          np.arange(n + i + 1, n + i + j + 1),
...                          [n + i + j]])
>>> indices = np.concatenate([np.arange(1, i + 1),
...                           graph.indices + i + 1,
...                           np.repeat(i + j + 1, j)])
>>> data = np.ones(n + i + j, dtype=int)
>>>
>>> graph_flow = csr_matrix((data, indices, indptr))
>>> print(graph_flow.toarray())
[[0 1 1 1 0 0 0 0 0]
 [0 0 0 0 0 1 0 1 0]
 [0 0 0 0 1 0 1 0 0]
 [0 0 0 0 0 1 1 0 0]
 [0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 0]]

此時，我們可以找到添加的Sink和添加的Source之間的最大流量，並且通過將流量函數限製在原始圖對應的塊上可以得到所需的匹配：

>>> result = maximum_flow(graph_flow, 0, i+j+1, method='dinic')
>>> matching = result.flow[1:i+1, i+1:i+j+1]
>>> print(matching.toarray())
[[0 1 0 0]
 [1 0 0 0]
 [0 0 1 0]]

這告訴我們\(U\) 中的第一個、第二個和第三個頂點分別與\(V\) 中的第二個、第一個和第三個頂點匹配。

雖然這通常解決了最大二分匹配問題，但請注意，專門針對該問題的算法，例如 maximum_bipartite_matching ，通常會表現得更好。

這種方法也可用於解決最大二分匹配問題的各種常見推廣。例如，如果某些頂點可以與多個其他頂點匹配，則可以通過適當地修改新圖的容量來處理。