Dijkstra 最短路径算法的C# 程序|贪心算法 7

给定一个图和图中的一个源顶点，找到从源到给定图中所有顶点的最短路径。

Dijkstra 的算法与 Prim 的最小生成树算法非常相似。与 Prim 的 MST 一样，我们生成一个以给定源为根的SPT（最短路径树） 。我们维护两组，一组包含包含在最短路径树中的顶点，另一组包含尚未包含在最短路径树中的顶点。在算法的每一步，我们都会找到一个顶点，该顶点在另一个集合（尚未包含的集合）中，并且与源的距离最小。

以下是 Dijkstra 算法中用于查找从单个源顶点到给定图中所有其他顶点的最短路径的详细步骤。
算法
1）创建一个集合sptSet （最短路径树集合），跟踪包含在最短路径树中的顶点，即计算并确定其与源的最小距离。最初，这个集合是空的。
2)为输入图中的所有顶点分配一个距离值。将所有距离值初始化为 INFINITE。将源顶点的距离值指定为 0，以便首先拾取它。
3)虽然sptSet不包括所有顶点
…… a)选择一个在sptSet中不存在且具有最小距离值的顶点 u。
…… b)将 u 包含到sptSet中。
…… c)更新 u 的所有相邻顶点的距离值。要更新距离值，请遍历所有相邻顶点。对于每个相邻的顶点v，如果u的距离值（来自源）和边uv的权重之和小于v的距离值，则更新v的距离值。

C#

// A C# program for Dijkstra's single
// source shortest path algorithm.
// The program is for adjacency matrix
// representation of the graph
using System;
  
class GFG {
    // A utility function to find the
    // vertex with minimum distance
    // value, from the set of vertices
    // not yet included in shortest
    // path tree
    static int V = 9;
    int minDistance(int[] dist,
                    bool[] sptSet)
    {
        // Initialize min value
        int min = int.MaxValue, min_index = -1;
  
        for (int v = 0; v < V; v++)
            if (sptSet[v] == false && dist[v] <= min) {
                min = dist[v];
                min_index = v;
            }
  
        return min_index;
    }
  
    // A utility function to print
    // the constructed distance array
    void printSolution(int[] dist, int n)
    {
        Console.Write("Vertex     Distance "
                      + "from Source\n");
        for (int i = 0; i < V; i++)
            Console.Write(i + " \t\t " + dist[i] + "\n");
    }
  
    // Function that implements Dijkstra's
    // single source shortest path algorithm
    // for a graph represented using adjacency
    // matrix representation
    void dijkstra(int[, ] graph, int src)
    {
        int[] dist = new int[V]; // The output array. dist[i]
        // will hold the shortest
        // distance from src to i
  
        // sptSet[i] will true if vertex
        // i is included in shortest path
        // tree or shortest distance from
        // src to i is finalized
        bool[] sptSet = new bool[V];
  
        // Initialize all distances as
        // INFINITE and stpSet[] as false
        for (int i = 0; i < V; i++) {
            dist[i] = int.MaxValue;
            sptSet[i] = false;
        }
  
        // Distance of source vertex
        // from itself is always 0
        dist[src] = 0;
  
        // Find shortest path for all vertices
        for (int count = 0; count < V - 1; count++) {
            // Pick the minimum distance vertex
            // from the set of vertices not yet
            // processed. u is always equal to
            // src in first iteration.
            int u = minDistance(dist, 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 < V; v++)
  
                // Update dist[v] only if is not in
                // sptSet, there is an edge from u
                // to v, and total weight of path
                // from src to v through u is smaller
                // than current value of dist[v]
                if (!sptSet[v] && graph[u, v] != 0 && 
                     dist[u] != int.MaxValue && dist[u] + graph[u, v] < dist[v])
                    dist[v] = dist[u] + graph[u, v];
        }
  
        // print the constructed distance array
        printSolution(dist, V);
    }
  
    // Driver Code
    public static void Main()
    {
        /* Let us create the example 
graph discussed above */
        int[, ] graph = new int[, ] { { 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, 14, 10, 0, 2, 0, 0 },
                                      { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
                                      { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
                                      { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
        GFG t = new GFG();
        t.dijkstra(graph, 0);
    }
}
  
// This code is contributed by ChitraNayal

输出：

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

请参考关于 Dijkstra 最短路径算法的完整文章 |贪婪算法 7 了解更多详情！