使用 Prim 和堆计算 MST 的总重量

如何解决使用 Prim 和堆计算 MST 的总重量

尝试实现一种方法，该方法使用 prim 和最小堆（使用优先级队列）构建 MST，并返回 MST 的总权重。

我的代码似乎产生了与预期不同的结果，但是，从我的代码来看，它似乎从根本上是正确的，并且与其他在线示例密切相关。

       for (int v = 0; v < size; v++)    {
            key[v] = Integer.MAX_VALUE;
            pred[v] = null;
            visited[v] = false;
        }

        int s = 0;
        key[s] = 0;

        for (int v = 0; v < size; v++)  {
            minHeap.add(new T(v,key[v],pred[v]));
        }

        while (!minHeap.isEmpty())  {
            int u = minHeap.poll().vertex;
            for (int v = 0; v < size; v++)  {
                if (g.getWeight(u,v) > 0 && !visited[v])  {
                    if (g.getWeight(u,v) < key[v]) {
                        key[v] = g.getWeight(u,v);
                        pred[v] = u;
                        minHeap.add(new T(v,pred[u]));
                    }
                }
            }
            visited[u] = true;
        }


        int distance = 0;
        for (int i = 0; i < size; i++)  {
            distance += key[i];
            if (!visited[i])
                return -1;
        }
        return distance;

当前输入是一个邻接数组：

5       16      5       8       19      9       8       1       5       8
16      10      19      7       7       5       15      4       7       18
5       19      1       7       1       20      12      15      9       2
8       7       7       14      11      18      13      5       11      14
19      7       1       11      0       15      10      17      0       8
9       5       20      18      15      0       11      20      10      7
8       15      12      13      10      11      8       14      20      20
1       4       15      5       17      20      14      12      0       8
5       7       9       11      0       10      20      0       5       7
8       18      2       14      8       7       20      8       7       15

预期输出为：36 当前输出为：32

解决方法

也许您的 minHeap 正在将项目排序到最大的键 [v] 而不是最小的。也许试试

minHeap.add(new T(v,Integer.MAXVALUE - key[v],pred[u]));

,

问题在于visited[u] = true 语句的位置。

在轮询 minHeap 中具有最高优先级的顶点之后和在循环检查相邻顶点之前将该语句移至修复它。