Ford-Fulkerson 最大流算法

流網絡（Flow Networks）指的是一個有向圖 G = (V, E)，其中每條邊 (u, v) ∈ E 均有一非負容量 c(u, v) ≥ 0。如果 (u, v) ∉ E 則可以規定 c(u, v) = 0。流網絡中有兩個特殊的頂點：源點 s （source）和匯點 t（sink）。為方便起見，假定每個頂點均處於從源點到匯點的某條路徑上，就是說，對每個頂點 v ∈ E，存在一條路徑 s --> v --> t。因此，圖 G 為連通圖，且 |E| ≥ |V| - 1。

下圖展示了一個流網絡實例。

設 G = (V, E) 是一個流網絡，其容量函數為 c。設 s 為網絡的源點，t 為匯點。G 的流的一個實值函數 f：V×V → R，且滿足下列三個性質：

• 容量限制（Capacity Constraint）：對所有頂點對 u, v ∈ V，要求 f(u, v) ≤ c(u, v)。
• 反對稱性（Skew Symmetry）：對所有頂點對 u, v ∈ V，要求 f(u, v) = - f(v, u)。
• 流守恆性（Flow Conservation）：對所有頂點對 u ∈ V - {s, t}，要求 Σ_v∈Vf(u, v) = 0。

f(u, v) 稱為從頂點 u 到頂點 v 的流，流的值定義為：|f| =Σ_v∈Vf(s, v)，即從源點 s 出發的總流。

最大流問題（Maximum-flow problem）中，給出源點 s 和匯點 t 的流網絡 G，希望找出從 s 到 t 的最大值流。

滿足流網絡的性質的實際上定義了問題的限制：

• 經過邊的流不能超過邊的容量；
• 除了源點 s 和匯點 t，對於其它所有頂點，流入量與流出量要相等；

上面的圖中描述的流網絡可簡化為下圖，其中源點 s = 0，匯點 t = 5。

上圖的最大流為 23，流向如下圖所示。

Ford-Fulkerson 算法是一種解決最大流的方法，其依賴於三種重要思想：

1. 殘留網絡（Residual networks）
2. 增廣路徑（Augmenting paths）
3. 割（Cut）

這些思想是最大流最小割定理的精髓，該定理用流網絡的割來描述最大流的值。

最大流最小割定理

如果 f 是具有源點 s 和匯點 t 的流網絡 G = (V, E) 中的一個流，則下列條件是等價的：

1. f 是 G 的一個最大流。
2. 殘留網絡 G_f 不包含增廣路徑。
3. 對 G 的某個割 (S, T)，有 |f| = c(S, T)。

Ford-Fulkerson 算法是一種迭代方法。開始時，對所有 u, v ∈ V 有 f(u, v) = 0，即初始狀態時流的值為 0。在每次迭代中，可通過尋找一條增廣路徑來增加流值。增廣路徑可以看做是從源點 s 到匯點 t 之間的一條路徑，沿該路徑可以壓入更多的流，從而增加流的值。反復進行這一過程，直至增廣路徑都被找出為止。最大流最小割定理將說明在算法終止時，這一過程可產生出最大流。

FORD-FULKERSON-METHOD(G, s, t)
  initialize flow f to 0
  while there exists an augmenting path p
    do augment flow f along p
  return f

上述偽碼實現的時間復雜度為 O(max_flow * E)。

C# 代碼實現如下：

using System;
using System.Collections.Generic;
using System.Linq;

namespace GraphAlgorithmTesting
{
  class Program
  {
    static void Main(string[] args)
    {
      Graph g = new Graph(6);
      g.AddEdge(0, 1, 16);
      g.AddEdge(0, 2, 13);
      g.AddEdge(1, 2, 10);
      g.AddEdge(1, 3, 12);
      g.AddEdge(2, 1, 4);
      g.AddEdge(2, 4, 14);
      g.AddEdge(3, 2, 9);
      g.AddEdge(3, 5, 20);
      g.AddEdge(4, 3, 7);
      g.AddEdge(4, 5, 4);

      Console.WriteLine();
      Console.WriteLine("Graph Vertex Count : {0}", g.VertexCount);
      Console.WriteLine("Graph Edge Count : {0}", g.EdgeCount);
      Console.WriteLine();

      int maxFlow = g.FordFulkerson(0, 5);
      Console.WriteLine("The Max Flow is : {0}", maxFlow);

      Console.ReadKey();
    }

    class Edge
    {
      public Edge(int begin, int end, int weight)
      {
        this.Begin = begin;
        this.End = end;
        this.Weight = weight;
      }

      public int Begin { get; private set; }
      public int End { get; private set; }
      public int Weight { get; private set; }

      public override string ToString()
      {
        return string.Format(
          "Begin[{0}], End[{1}], Weight[{2}]",
          Begin, End, Weight);
      }
    }

    class Graph
    {
      private Dictionary<int, List<Edge>> _adjacentEdges
        = new Dictionary<int, List<Edge>>();

      public Graph(int vertexCount)
      {
        this.VertexCount = vertexCount;
      }

      public int VertexCount { get; private set; }

      public IEnumerable<int> Vertices
      {
        get
        {
          return _adjacentEdges.Keys;
        }
      }

      public IEnumerable<Edge> Edges
      {
        get
        {
          return _adjacentEdges.Values.SelectMany(e => e);
        }
      }

      public int EdgeCount
      {
        get
        {
          return this.Edges.Count();
        }
      }

      public void AddEdge(int begin, int end, int weight)
      {
        if (!_adjacentEdges.ContainsKey(begin))
        {
          var edges = new List<Edge>();
          _adjacentEdges.Add(begin, edges);
        }

        _adjacentEdges[begin].Add(new Edge(begin, end, weight));
      }

      public int FordFulkerson(int s, int t)
      {
        int u, v;

        // Create a residual graph and fill the residual graph with
        // given capacities in the original graph as residual capacities
        // in residual graph
        int[,] residual = new int[VertexCount, VertexCount];

        // Residual graph where rGraph[i,j] indicates 
        // residual capacity of edge from i to j (if there
        // is an edge. If rGraph[i,j] is 0, then there is not) 
        for (u = 0; u < VertexCount; u++)
          for (v = 0; v < VertexCount; v++)
            residual[u, v] = 0;
        foreach (var edge in this.Edges)
        {
          residual[edge.Begin, edge.End] = edge.Weight;
        }

        // This array is filled by BFS and to store path
        int[] parent = new int[VertexCount];

        // There is no flow initially
        int maxFlow = 0;

        // Augment the flow while there is path from source to sink
        while (BFS(residual, s, t, parent))
        {
          // Find minimum residual capacity of the edhes along the
          // path filled by BFS. Or we can say find the maximum flow
          // through the path found.
          int pathFlow = int.MaxValue;
          for (v = t; v != s; v = parent[v])
          {
            u = parent[v];
            pathFlow = pathFlow < residual[u, v]
              ? pathFlow : residual[u, v];
          }

          // update residual capacities of the edges and reverse edges
          // along the path
          for (v = t; v != s; v = parent[v])
          {
            u = parent[v];
            residual[u, v] -= pathFlow;
            residual[v, u] += pathFlow;
          }

          // Add path flow to overall flow
          maxFlow += pathFlow;
        }

        // Return the overall flow
        return maxFlow;
      }

      // Returns true if there is a path from source 's' to sink 't' in
      // residual graph. Also fills parent[] to store the path.
      private bool BFS(int[,] residual, int s, int t, int[] parent)
      {
        bool[] visited = new bool[VertexCount];
        for (int i = 0; i < visited.Length; i++)
        {
          visited[i] = false;
        }

        Queue<int> q = new Queue<int>();

        visited[s] = true;
        q.Enqueue(s);
        parent[s] = -1;

        // standard BFS loop
        while (q.Count > 0)
        {
          int u = q.Dequeue();

          for (int v = 0; v < VertexCount; v++)
          {
            if (!visited[v]
              && residual[u, v] > 0)
            {
              q.Enqueue(v);
              visited[v] = true;
              parent[v] = u;
            }
          }
        }

        // If we reached sink in BFS starting from source, 
        // then return true, else false
        return visited[t] == true;
      }
    }
  }
}

運行結果如下：

參考資料

• 廣度優先搜索
• 深度優先搜索
• Breadth First Traversal for a Graph
• Depth First Traversal for a Graph
• Dijkstra 單源最短路徑算法
• Bellman-Ford 單源最短路徑算法
• Bellman–Ford algorithm
• Introduction To Algorithm
• Floyd-Warshall's algorithm
• Bellman-Ford algorithm for single-source shortest paths
• Dynamic Programming | Set 23 (Bellman–Ford Algorithm)
• Dynamic Programming | Set 16 (Floyd Warshall Algorithm)
• Johnson’s algorithm for All-pairs shortest paths
• Floyd-Warshall's algorithm
• 最短路徑算法--Dijkstra算法，Bellmanford算法，Floyd算法，Johnson算法
• QuickGraph, Graph Data Structures And Algorithms for .NET
• CHAPTER 26: ALL-PAIRS SHORTEST PATHS

本篇文章《Ford-Fulkerson 最大流算法》由 Dennis Gao 發表自博客園，未經作者本人同意禁止任何形式的轉載，任何自動或人為的爬蟲轉載行為均為耍流氓。