Prim最小生成树

一、基本思想

🍘Prim算法是一种用于在加权无向图中寻找最小生成树(MST, Minimum Spanning Tree)的贪心算法。最小生成树是指连接图中所有顶点的边的权重之和最小的树。

🍙Prim算法的核心思想是：从任意一个顶点开始，每次选择一条连接已选顶点集合和未选顶点集合的最小权重边，将该边加入生成树，并将对应的顶点加入已选集合。

二、算法步骤

🍑1.初始化

①选择一个起始顶点

②将该顶点加入已选集合

③初始化所有其他顶点到已选集合的最小距离为无穷大

🍒2.重复以下步骤直到所有顶点都被选中

①找出连接已选集合和未选集合的最小权重边

②将该边加入最小生成树

③将对应的顶点加入已选集合

④更新未选顶点到已选集合的最小距离 

三、典型例题

【问题描述】
 已知含有n个顶点的带权连通无向图，采用邻接矩阵存储，邻接矩阵以三元组的形式给出，只给出不包括主对角线元素在内的下三角形部分的元素，且不包括不相邻的顶点对。请采用Prim算法，求该连通图从1号顶点出发的最小生成树的权值之和。
【输入形式】
 第一行给出结点个数n和三元组的个数count，以下每行给出一个三元组，数之间用空格隔开。（注意这里顶点的序号是从1到n，而不是0到n-1，程序里要小心！）
【输出形式】
 求解的最小生成树的各条边、边的权值之和
【样例输入】
 5 8
 2 1 7
 3 1 6
 3 2 8
 4 1 9
 4 2 4
 4 3 6
 5 2 4
 5 4 2
【样例输出】

1-3:6
3-4:6
4-5:2
4-2:4
18

#include<bits/stdc++.h>
using namespace std;
#define max 100  // 定义最大顶点数

// 顶点结构体（存储权值）
typedef struct
{
    int data;  // 权值（这里用于存储边的权重）
}node;

// 邻接矩阵结构体
typedef struct
{
    node arcs[max][max];  // 邻接矩阵，存储边权值
    int vexnum, arcnum;   // 顶点数和边数
}Matrix;

// Prim算法辅助结构体
struct
{
    int adjvex;   // 存储当前顶点到MST的最小边的另一端顶点
    int lowcost;  // 存储当前顶点到MST的最小边的权值
}closedge[max];   // 辅助数组，用于记录各顶点到MST的最小权值边

// 在closedge数组中找到lowcost最小的顶点（未加入MST的）
int minnum(Matrix g)
{
    int min = 100000;  // 初始化为一个大数
    int c;
    for(int i = 1; i <= g.vexnum; i++)
    {
       // 找到未加入MST(lowcost≠0)且权值最小的顶点
       if(min > closedge[i].lowcost && closedge[i].lowcost != 0)
       {
           min = closedge[i].lowcost;
           c = i;  // 记录顶点编号
       }
    }
    return c;
}

// Prim算法核心函数（从顶点u开始构建最小生成树）
void mintree(Matrix g, int u)
{
    int sum = 0;  // 记录最小生成树的总权值
    
    closedge[u].lowcost = 0;  // 将起始顶点u加入MST
    
    // 初始化closedge数组
    for(int i = 1; i <= g.vexnum; i++)
    {
        if(i != u)
        {
            closedge[i].adjvex = u;  // 初始时所有顶点都与u相连
            closedge[i].lowcost = g.arcs[u][i].data;  // 存储u到各顶点的权值
        }
    }
    
    // 需要选择n-1条边（n是顶点数）
    for(int e = 1; e <= g.vexnum-1; e++)
    {
        int v = minnum(g);  // 找到当前离MST最近的顶点v
        u = closedge[v].adjvex;  // 获取v连接的MST中的顶点u
        
        // 输出选择的边及其权值
        cout << u << '-' << v << ':';
        cout << closedge[v].lowcost << endl;
        
        sum += closedge[v].lowcost;  // 累加总权值
        closedge[v].lowcost = 0;     // 将v加入MST
        
        // 更新closedge数组
        for(int i = 1; i <= g.vexnum; i++)
        {
            // 如果v到i的权值小于当前记录的最小权值
            if(g.arcs[v][i].data < closedge[i].lowcost)
            {
                closedge[i].lowcost = g.arcs[v][i].data;  // 更新最小权值
                closedge[i].adjvex = v;                   // 更新连接顶点
            }
        }
    }
    cout << sum << endl;  // 输出最小生成树的总权值
}

int main()
{
    int n, m;  // n-顶点数，m-边数
    cin >> n >> m;
    
    Matrix g;
    g.vexnum = n;
    g.arcnum = m;
    
    // 初始化邻接矩阵（权值设为一个大数，表示无穷大）
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= n; j++)
        {
            g.arcs[i][j].data = 100000;
        }
    }
    
    // 输入边信息（无向图）
    for(int i = 1; i <= m; i++)
    {
        int a, b, weight;
        cin >> a >> b >> weight;
        g.arcs[a][b].data = weight;
        g.arcs[b][a].data = weight;  // 无向图，对称赋值
    }
    
    mintree(g, 1);  // 从顶点1开始构建最小生成树
    return 0;
}