Prim算法实现最小生成树

Prim算法是一种用来寻找图的最小生成树的贪心算法。最小生成树是连接图中所有顶点的边的子集，这些边的权重总和最小，且形成一个树形结构，包含所有顶点。

Prim算法的基本步骤如下：

1. 初始化：
   • 选择任意一个顶点作为起始点（通常选择第一个顶点）
   • 创建一个优先队列（最小堆）来存储顶点和它们当前的最小边权重。
   • 创建一个集合来记录已经加入最小生成树的顶点。
2. 生长最小生成树：
   • 从优先队列中取出权重最小的顶点（如果存在）
   • 将该顶点加入最小生成树集合
   • 更新与该顶点相邻的顶点的权重，如果通过当前顶点可以找到更短的路径到达这些顶点，则更新它们的权重
3. 重复：
   • 重复步骤2，直到所有顶点都被加入最小生成树集合
4. 输出：
   • 最小生成树的总权重是优先队列中所有被取出的边的权重之和

#include <iostream>
#include <vector>
#include <climits>


const int MAX_VERTICES = 100;  // 最大顶点数
const int INF = INT_MAX;  // 表示不可达


// 使用邻接矩阵表示无向图
class UndirectedGraph {
public:
    int vertex_number;  // 顶点数
    std::vector<std::vector<int>> adjacency_matrix;  // 邻接矩阵

    // 构造函数，并将参数赋值给成员变量
    UndirectedGraph(int val) : vertex_number(val), adjacency_matrix(val, std::vector<int>(val, INF)) {
        // 查看邻接矩阵的初始值，并无实际意义
        for (int i = 0; i < adjacency_matrix.size(); ++i) {
            for (auto value : adjacency_matrix[i]) {
                std::cout << value << " ";
            }
        }
        std::cout << std::endl;
    }
    
    // 添加边，传入三个参数，u和v是顶点，w为权重
    void add_edge(int u, int v, int w) {
        adjacency_matrix[u][v] = w;
        adjacency_matrix[v][u] = w;  // 如果是无向图，则需要添加这行
    }
};


// Prim算法实现
void prim_mst(const UndirectedGraph& graph) {
    int vn = graph.vertex_number;
    std::vector<int> key(vn, INF);  // 存储从集合外到集合内的最小权重
    std::vector<bool> in_mst(vn, false);  // 标记顶点是否已经在MST中
    std::vector<int> parent(vn, -1);  // 存储MST中的边的父顶点

    // 从第一个顶点开始构建MST
    key[0] = 0;  // 顶点0是起始点

    for (int count = 0; count < vn; ++count) {
        // 找到不在MST中且key值最小的顶点
        int u = -1;
        int min_weight = INF;
        for (int v = 0; v < vn; ++v) {
            if (!in_mst[v] && key[v] < min_weight) {
                u = v;
                min_weight = key[v];
            }
        }

        in_mst[u] = true;  // 将顶点u加入MST

        // 更新与顶点u相邻的顶点的key值
        for (int v = 0; v < vn; ++v) {
            if (graph.adjacency_matrix[u][v] && !in_mst[v] && graph.adjacency_matrix[u][v] < key[v]) {
                parent[v] = u;
                key[v] = graph.adjacency_matrix[u][v];
            }
        }
    }

    // 输出MST的详细信息
    int totalWeight = 0;
    for (int i = 1; i < vn; ++i) {
        std::cout << "Edge (" << parent[i]+1 << ", " << i+1 << ") -> Weight = " << graph.adjacency_matrix[parent[i]][i] << std::endl;
        totalWeight += graph.adjacency_matrix[parent[i]][i];
    }
    std::cout << "Total weight of MST = " << totalWeight << std::endl;
}

int main() {
    UndirectedGraph g(7);  // 实例化类对象

    // 构造无向有权图
    g.add_edge(0, 1, 2);
    g.add_edge(0, 2, 4);
    g.add_edge(0, 3, 1);
    g.add_edge(1, 3, 3);
    g.add_edge(1, 4, 10);
    g.add_edge(2, 3, 2);
    g.add_edge(2, 5, 5);
    g.add_edge(3, 4, 7);
    g.add_edge(3, 5, 8);
    g.add_edge(3, 6, 4);
    g.add_edge(4, 6, 6);
    g.add_edge(5, 6, 1);

    std::cout << "Following are the edges in the constructed MST:\n";
    prim_mst(g);

    return 0;
}
---------
Following are the edges in the constructed MST:
Edge (1, 2) -> Weight = 2
Edge (4, 3) -> Weight = 2
Edge (1, 4) -> Weight = 1
Edge (7, 5) -> Weight = 6
Edge (7, 6) -> Weight = 1
Edge (4, 7) -> Weight = 4
Total weight of MST = 16