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		Distance from Source");
      for (int i = 0; i < dist.Length; i++)
      {
        Console.WriteLine("{0}		{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 发表自博客园，未经作者本人同意禁止任何形式的转载，任何自动或人为的爬虫转载行为均为耍流氓。