Floyd-Warshall 全源最短路徑算法

Floyd-Warshall 算法采用動態規划方案來解決在一個有向圖 G = (V, E) 上每對頂點間的最短路徑問題，即全源最短路徑問題（All-Pairs Shortest Paths Problem），其中圖 G 允許存在權值為負的邊，但不存在權值為負的回路。Floyd-Warshall 算法的運行時間為 Θ(V³)。

Floyd-Warshall 算法由 Robert Floyd 於 1962 年提出，但其實質上與 Bernad Roy 於 1959 年和 Stephen Warshall 於 1962 年提出的算法相同。

解決單源最短路徑問題的方案有 Dijkstra 算法和 Bellman-Ford 算法，對於全源最短路徑問題可以認為是單源最短路徑問題（Single Source Shortest Paths Problem）的推廣，即分別以每個頂點作為源頂點並求其至其它頂點的最短距離。更通用的全源最短路徑算法包括：

• 針對稠密圖的 Floyd-Warshall 算法：時間復雜度為 O(V³)；
• 針對稀疏圖的 Johnson 算法：時間復雜度為 O(V²logV + VE)；

最短路徑算法中的最優子結構指的是兩頂點之間的最短路徑包括路徑上其它頂點的最短路徑。具體描述為：對於給定的帶權圖 G = (V, E)，設 p = <v₁, v₂, …,v_k> 是從 v₁ 到 v_k 的最短路徑，那么對於任意 i 和 j，1 ≤ i ≤ j ≤ k，p_ij = <v_i, v_i+1, …, v_j> 為 p 中頂點 v_i 到 v_j 的子路徑，那么 p_ij 是頂點 v_i 到 v_j 的最短路徑。

Floyd-Warshall 算法的設計基於了如下觀察。設帶權圖 G = (V, E) 中的所有頂點 V = {1, 2, . . . , n}，考慮一個頂點子集 {1, 2, . . . , k}。對於任意對頂點 i, j，考慮從頂點 i 到 j 的所有路徑的中間頂點都來自該子集 {1, 2, . . . , k}，設 p 是該子集中的最短路徑。Floyd-Warshall 算法描述了 p 與 i, j 間最短路徑及中間頂點集合 {1, 2, . . . , k - 1} 的關系，該關系依賴於 k 是否是路徑 p 上的一個中間頂點。

算法偽碼如下：

最短路徑算法的設計都使用了松弛（relaxation）技術。在算法開始時只知道圖中邊的權值，然后隨着處理逐漸得到各對頂點的最短路徑的信息，算法會逐漸更新這些信息，每步都會檢查是否可以找到一條路徑比當前已有路徑更短，這一過程通常稱為松弛（relaxation）。

C# 代碼實現：

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

namespace GraphAlgorithmTesting
{
  class Program
  {
    static void Main(string[] args)
    {
      int[,] graph = new int[9, 9]
      {
        {0, 4, 0, 0, 0, 0, 0, 8, 0},
        {4, 0, 8, 0, 0, 0, 0, 11, 0},
        {0, 8, 0, 7, 0, 4, 0, 0, 2},
        {0, 0, 7, 0, 9, 14, 0, 0, 0},
        {0, 0, 0, 9, 0, 10, 0, 0, 0},
        {0, 0, 4, 0, 10, 0, 2, 0, 0},
        {0, 0, 0, 14, 0, 2, 0, 1, 6},
        {8, 11, 0, 0, 0, 0, 1, 0, 7},
        {0, 0, 2, 0, 0, 0, 6, 7, 0}
      };

      Graph g = new Graph(graph.GetLength(0));
      for (int i = 0; i < graph.GetLength(0); i++)
      {
        for (int j = 0; j < graph.GetLength(1); j++)
        {
          if (graph[i, j] > 0)
            g.AddEdge(i, j, graph[i, j]);
        }
      }

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

      int[,] distSet = g.FloydWarshell();
      PrintSolution(g, distSet);

      // build a directed and negative weighted graph
      Graph directedGraph1 = new Graph(5);
      directedGraph1.AddEdge(0, 1, -1);
      directedGraph1.AddEdge(0, 2, 4);
      directedGraph1.AddEdge(1, 2, 3);
      directedGraph1.AddEdge(1, 3, 2);
      directedGraph1.AddEdge(1, 4, 2);
      directedGraph1.AddEdge(3, 2, 5);
      directedGraph1.AddEdge(3, 1, 1);
      directedGraph1.AddEdge(4, 3, -3);

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

      int[,] distSet1 = directedGraph1.FloydWarshell();
      PrintSolution(directedGraph1, distSet1);

      // build a directed and positive weighted graph
      Graph directedGraph2 = new Graph(4);
      directedGraph2.AddEdge(0, 1, 5);
      directedGraph2.AddEdge(0, 3, 10);
      directedGraph2.AddEdge(1, 2, 3);
      directedGraph2.AddEdge(2, 3, 1);

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

      int[,] distSet2 = directedGraph2.FloydWarshell();
      PrintSolution(directedGraph2, distSet2);

      Console.ReadKey();
    }

    private static void PrintSolution(Graph g, int[,] distSet)
    {
      Console.Write("\t");
      for (int i = 0; i < g.VertexCount; i++)
      {
        Console.Write(i + "\t");
      }
      Console.WriteLine();
      Console.Write("\t");
      for (int i = 0; i < g.VertexCount; i++)
      {
        Console.Write("-" + "\t");
      }
      Console.WriteLine();
      for (int i = 0; i < g.VertexCount; i++)
      {
        Console.Write(i + "|\t");
        for (int j = 0; j < g.VertexCount; j++)
        {
          if (distSet[i, j] == int.MaxValue)
          {
            Console.Write("INF" + "\t");
          }
          else
          {
            Console.Write(distSet[i, j] + "\t");
          }
        }
        Console.WriteLine();
      }
    }

    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 int EdgeCount
      {
        get
        {
          return _adjacentEdges.Values.SelectMany(e => e).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[,] FloydWarshell()
      {
        /* distSet[,] will be the output matrix that will finally have the shortest 
           distances between every pair of vertices */
        int[,] distSet = new int[VertexCount, VertexCount];

        for (int i = 0; i < VertexCount; i++)
        {
          for (int j = 0; j < VertexCount; j++)
          {
            distSet[i, j] = int.MaxValue;
          }
        }
        for (int i = 0; i < VertexCount; i++)
        {
          distSet[i, i] = 0;
        }

        /* Initialize the solution matrix same as input graph matrix. Or 
           we can say the initial values of shortest distances are based
           on shortest paths considering no intermediate vertex. */
        foreach (var edge in _adjacentEdges.Values.SelectMany(e => e))
        {
          distSet[edge.Begin, edge.End] = edge.Weight;
        }

        /* Add all vertices one by one to the set of intermediate vertices.
          ---> Before start of a iteration, we have shortest distances between all
          pairs of vertices such that the shortest distances consider only the
          vertices in set {0, 1, 2, .. k-1} as intermediate vertices.
          ---> After the end of a iteration, vertex no. k is added to the set of
          intermediate vertices and the set becomes {0, 1, 2, .. k} */
        for (int k = 0; k < VertexCount; k++)
        {
          // Pick all vertices as source one by one
          for (int i = 0; i < VertexCount; i++)
          {
            // Pick all vertices as destination for the above picked source
            for (int j = 0; j < VertexCount; j++)
            {
              // If vertex k is on the shortest path from
              // i to j, then update the value of distSet[i,j]
              if (distSet[i, k] != int.MaxValue
                && distSet[k, j] != int.MaxValue
                && distSet[i, k] + distSet[k, j] < distSet[i, j])
              {
                distSet[i, j] = distSet[i, k] + distSet[k, j];
              }
            }
          }
        }

        return distSet;
      }
    }
  }
}

運行結果如下：

參考資料

• 廣度優先搜索
• 深度優先搜索
• 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

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