Dijkstra 單源最短路徑算法

Dijkstra 算法是一種用於計算帶權有向圖中單源最短路徑（SSSP：Single-Source Shortest Path）的算法，由計算機科學家 Edsger Dijkstra 於 1956 年構思並於 1959 年發表。其解決的問題是：給定圖 G 和源頂點 v，找到從 v 至圖中所有頂點的最短路徑。

Dijkstra 算法采用貪心算法（Greedy Algorithm）范式進行設計。在最短路徑問題中，對於帶權有向圖 G = (V, E)，Dijkstra 算法的初始實現版本未使用最小優先隊列實現，其時間復雜度為 O(V²)，基於 Fibonacci heap 的最小優先隊列實現版本，其時間復雜度為 O(E + VlogV)。

Bellman-Ford 算法和 Dijkstra 算法同為解決單源最短路徑的算法。對於帶權有向圖 G = (V, E)，Dijkstra 算法要求圖 G 中邊的權值均為非負，而 Bellman-Ford 算法能適應一般的情況（即存在負權邊的情況）。一個實現的很好的 Dijkstra 算法比 Bellman-Ford 算法的運行時間 O(V*E) 要低。

Dijkstra 算法描述：

1. 創建源頂點 v 到圖中所有頂點的距離的集合 distSet，為圖中的所有頂點指定一個距離值，初始均為 Infinite，源頂點距離為 0；
2. 創建 SPT（Shortest Path Tree）集合 sptSet，用於存放包含在 SPT 中的頂點；
3. 如果 sptSet 中並沒有包含所有的頂點，則：
   • 選中不包含在 sptSet 中的頂點 u，u 為當前 sptSet 中未確認的最短距離頂點；
   • 將 u 包含進 sptSet；
   • 更新 u 的所有鄰接頂點的距離值；

偽碼實現如下：

function Dijkstra(Graph, source):

    dist[source] ← 0          // Distance from source to source
    prev[source] ← undefined  // Previous node in optimal path initialization

    for each vertex v in Graph:  // Initialization
        if v ≠ source            // Where v has not yet been removed from Q (unvisited nodes)
            dist[v] ← infinity   // Unknown distance function from source to v
            prev[v] ← undefined  // Previous node in optimal path from source
        end if 
        add v to Q               // All nodes initially in Q (unvisited nodes)
    end for
    
    while Q is not empty:
        u ← vertex in Q with min dist[u]  // Source node in first case
        remove u from Q 
        
        for each neighbor v of u:         // where v has not yet been removed from Q.
            alt ← dist[u] + length(u, v)
            if alt < dist[v]:             // A shorter path to v has been found
                dist[v] ← alt 
                prev[v] ← u 
            end if
        end for
    end while

    return dist[], prev[]

end function

例如，下面是一個包含 9 個頂點的圖，每條邊分別標識了距離。

源頂點 source = 0，初始時，

• sptSet = {false, false, false, false, false, false, false, false, false};
• distSet = {0, INF, INF, INF, INF, INF, INF, INF, INF};

將 0 包含至 sptSet 中；

• sptSet = {true, false, false, false, false, false, false, false, false};

更新 0 至其鄰接節點的距離；

• distSet = {0, 4, INF, INF, INF, INF, INF, 8, INF};

選擇不在 sptSet 中的 Min Distance 的頂點，為頂點 1，則將 1 包含至 sptSet；

• sptSet = {true, true, false, false, false, false, false, false, false};

更新 1 至其鄰接節點的距離；

• distSet = {0, 4, 12, INF, INF, INF, INF, 8, INF};

選擇不在 sptSet 中的 Min Distance 的頂點，為頂點 7，則將 7 包含至 sptSet；

• sptSet = {true, true, false, false, false, false, false, true, false};

更新 7 至其鄰接節點的距離；

• distSet = {0, 4, 12, INF, INF, INF, 9, 8, 15};

選擇不在 sptSet 中的 Min Distance 的頂點，為頂點 6，則將 6 包含至 sptSet；

• sptSet = {true, true, false, false, false, false, true, true, false};

更新 6 至其鄰接節點的距離；

• distSet = {0, 4, 12, INF, INF, 11, 9, 8, 15};

以此類推，直到遍歷結束。

• sptSet = {true, true, true, true, true, true, true, true, true};
• distSet = {0, 4, 12, 19, 21, 11, 9, 8, 14};

最終結果為源頂點 0 至所有頂點的距離：

Vertex   Distance from Source
0                0
1                4
2                12
3                19
4                21
5                11
6                9
7                8
8                14

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]);
        }
      }

      int[] dist = g.Dijkstra(0);
      Console.WriteLine("Vertex\t\tDistance from Source");
      for (int i = 0; i < dist.Length; i++)
      {
        Console.WriteLine("{0}\t\t{1}", i, dist[i]);
      }

      Console.ReadKey();
    }

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

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

    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 void AddEdge(int begin, int end, int distance)
      {
        if (!_adjacentEdges.ContainsKey(begin))
        {
          var edges = new List<Edge>();
          _adjacentEdges.Add(begin, edges);
        }

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

      public int[] Dijkstra(int source)
      {
        // dist[i] will hold the shortest distance from source to i
        int[] distSet = new int[VertexCount];

        // sptSet[i] will true if vertex i is included in shortest
        // path tree or shortest distance from source to i is finalized
        bool[] sptSet = new bool[VertexCount];

        // initialize all distances as INFINITE and stpSet[] as false
        for (int i = 0; i < VertexCount; i++)
        {
          distSet[i] = int.MaxValue;
          sptSet[i] = false;
        }

        // distance of source vertex from itself is always 0
        distSet[source] = 0;

        // find shortest path for all vertices
        for (int i = 0; i < VertexCount - 1; i++)
        {
          // pick the minimum distance vertex from the set of vertices not
          // yet processed. u is always equal to source in first iteration.
          int u = CalculateMinDistance(distSet, sptSet);

          // mark the picked vertex as processed
          sptSet[u] = true;

          // update dist value of the adjacent vertices of the picked vertex.
          for (int v = 0; v < VertexCount; v++)
          {
            // update dist[v] only if is not in sptSet, there is an edge from 
            // u to v, and total weight of path from source to  v through u is 
            // smaller than current value of dist[v]
            if (!sptSet[v]
              && distSet[u] != int.MaxValue
              && _adjacentEdges[u].Exists(e => e.End == v))
            {
              int d = _adjacentEdges[u].Single(e => e.End == v).Distance;
              if (distSet[u] + d < distSet[v])
              {
                distSet[v] = distSet[u] + d;
              }
            }
          }
        }

        return distSet;
      }

      /// <summary>
      /// A utility function to find the vertex with minimum distance value, 
      /// from the set of vertices not yet included in shortest path tree
      /// </summary>
      private int CalculateMinDistance(int[] distSet, bool[] sptSet)
      {
        int minDistance = int.MaxValue;
        int minDistanceIndex = -1;

        for (int v = 0; v < VertexCount; v++)
        {
          if (!sptSet[v] && distSet[v] <= minDistance)
          {
            minDistance = distSet[v];
            minDistanceIndex = v;
          }
        }

        return minDistanceIndex;
      }
    }
  }
}

參考資料

• 廣度優先搜索
• Dijkstra's algorithm
• Greedy Algorithms | Set 7 (Dijkstra’s shortest path algorithm)
• Bellman-Ford 單源最短路徑算法
• Introduction to Algorithms 6.006 - Lecture 16

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