为啥在 Prim 的 MST 算法中得到最小顶点？

Posted 2023-02-22

【中文标题】为啥在 Prim 的 MST 算法中得到最小顶点？

【英文标题】：Why get minimum vertex in Prim's MST algorithm?为什么在 Prim 的 MST 算法中得到最小顶点？

【发布时间】：2016-08-14 05:39:25

【问题描述】：

据我了解，Prim 的 MST 算法将遍历图中的所有顶点，选择一条最佳边到达每个顶点。因此，每次迭代都会为每个相邻顶点选择一个最优成本。因此，无论首先使用哪个顶点，最终结果都应该是相同的，因为在选择下一个顶点之前就已经选择了最优成本。

因此，我不明白为什么算法必须在每次迭代中选择成本最低的顶点。为了使我的描述更清楚，我包含了来自 geeksforgeeks.org 的示例代码和图表：

// A C / C++ program for Prim's Minimum Spanning Tree (MST) algorithm. 
// The program is for adjacency matrix representation of the graph

#include <stdio.h>
#include <limits.h>

// Number of vertices in the graph
#define V 5

// A utility function to find the vertex with minimum key value, from
// the set of vertices not yet included in MST
int minKey(int key[], bool mstSet[])

   // Initialize min value
   int min = INT_MAX, min_index;

   for (int v = 0; v < V; v++)
     if (mstSet[v] == false && key[v] < min)
         min = key[v], min_index = v;

   return min_index;


// A utility function to print the constructed MST stored in parent[]
int printMST(int parent[], int n, int graph[V][V])

   printf("Edge   Weight\n");
   for (int i = 1; i < V; i++)
      printf("%d - %d    %d \n", parent[i], i, graph[i][parent[i]]);


// Function to construct and print MST for a graph represented using adjacency
// matrix representation
void primMST(int graph[V][V])

     int parent[V]; // Array to store constructed MST
     int key[V];   // Key values used to pick minimum weight edge in cut
     bool mstSet[V];  // To represent set of vertices not yet included in MST

     // Initialize all keys as INFINITE
     for (int i = 0; i < V; i++)
        key[i] = INT_MAX, mstSet[i] = false;

     // Always include first 1st vertex in MST.
     key[0] = 0;     // Make key 0 so that this vertex is picked as first vertex
     parent[0] = -1; // First node is always root of MST 

     // The MST will have V vertices
     for (int count = 0; count < V-1; count++)
     
        // Pick thd minimum key vertex from the set of vertices
        // not yet included in MST
        int u = minKey(key, mstSet);

        // Add the picked vertex to the MST Set
        mstSet[u] = true;

        // Update key value and parent index of the adjacent vertices of
        // the picked vertex. Consider only those vertices which are not yet
        // included in MST
        for (int v = 0; v < V; v++)

           // graph[u][v] is non zero only for adjacent vertices of m
           // mstSet[v] is false for vertices not yet included in MST
           // Update the key only if graph[u][v] is smaller than key[v]
          if (graph[u][v] && mstSet[v] == false && graph[u][v] <  key[v])
             parent[v]  = u, key[v] = graph[u][v];
     

     // print the constructed MST
     printMST(parent, V, graph);



// driver program to test above function
int main()

   /* Let us create the following graph
          2    3
      (0)--(1)--(2)
       |   / \   |
      6| 8/   \5 |7
       | /     \ |
      (3)-------(4)
            9          */
   int graph[V][V] = 0, 2, 0, 6, 0,
                      2, 0, 3, 8, 5,
                      0, 3, 0, 0, 7,
                      6, 8, 0, 0, 9,
                      0, 5, 7, 9, 0,
                     ;

    // Print the solution
    primMST(graph);

    return 0;

从下面的代码块我们可以看出，每次迭代都会为每个邻居选择最优权重（在这种情况下，只有一条边连接任意两个顶点）：

if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v])
    parent[v] = u, key[v] = graph[u][v];

我们以顶点 7 为例，它有 3 条边。边 6-7 最终将从边 0-7、8-7 和 6-7 中选择，因为它的权重是最小的，无论我们是先评估顶点 0-7、8-7 还是 6-7，因为最佳权重 = min（所有相邻边的权重）。因此，每次迭代都选择最小权重的顶点似乎是多余的。

有人可以向我解释一下在以下代码块中为每次迭代选择最小权重顶点的目的是什么吗？

// Pick thd minimum key vertex from the set of vertices
// not yet included in MST
int u = minKey(key, mstSet);

【参考方案1】：

我们以顶点 7 为例，它有 3 条边。边缘 6-7 将 最终从边缘 0-7、8-7 和 6-7 中选择，因为它的权重是 最小值，无论我们评估顶点 0-7、8-7 还是 6-7 首先是因为最佳权重 = min（所有相邻边的权重）。 因此，每次选择最小权重顶点似乎是多余的 迭代。

看起来你混淆了这两个循环的目的。内部循环不选择任何东西。它只是计算权重。选择的是外部循环。

这样看。想象一下只有一个循环作为开始，并且我们已经选择了一个随机的起始顶点。现在这个循环需要获得优势。当然，它会越过相邻的边缘并拾取最小值。 如何做到这一点并不重要：权重是分配给顶点还是只是在边缘上循环并选择最好的。

但是，当顶点越来越多时，事情就会变得复杂。一旦你添加了另一个顶点，你可能已经发现了一种更好的方法来获得一个新的顶点。假设您从顶点 2 开始。添加顶点 8。现在您可以从 2（权重 8）到 1，从 2（权重 7）到 3，从 8（权重 6）到 6，从 8（权重 7）到 7。然而，一旦你从 8 到 6，你现在有一个更好的方法从 6 到 7，重量只有 1，而不是重量 7（边缘 8-7）。所以你需要更新你对最佳路径的概念。

一种方法是在每次迭代时简单地遍历所有与 MST 集合中已包含的顶点相邻的所有边，然后选择最好的边。这引入了两个内部循环来找到最小值：一个在 MST 集中的顶点上，另一个在与每个这样的顶点相邻的边上。对于具有n 顶点和大约n^2 边的近乎完整的图，您总共将获得O(n^3)。

所以这个算法做了什么，它只循环顶点而不是边。每个顶点都保留从当前 MST 集到那里的最简单方法的权重。这允许我们将内部循环一分为二。通过遍历所有顶点来找到最好的下一个顶点。它选择最好的相邻的，因为非相邻的权重是无限的。这正是令人困惑的行所做的。我是O(n)。

另一个内部循环更新权重。但是，由于更新可能仅由添加新顶点引起，因此只需要考虑与该特定顶点相邻的边！又是O(n)（假设一个几乎完整的图表）。因此，您可以将所有三个循环的复杂度降低到 O(n^2)。

事实上，如果你使用邻接矩阵，图形是否完整甚至都没有关系。要摆脱 minKey 部分，您需要创建 三个 嵌套循环：第一个内部循环将遍历 MST 集中的所有顶点，最里面的循环将遍历其相邻边缘包括不存在的。 minKey 技巧只允许拥有这个：

    // Update key value and parent index of the adjacent vertices of
    // the picked vertex. Consider only those vertices which are not yet
    // included in MST
    for (int v = 0; v < V; v++) // note there is no loop over `u`!