最小生成树的性质与prim算法（C++实现）

1、最小生成树（Minimum Spanning Tree, MST）的性质

在一个给定的无向图G(V,E）中求一棵树T，使得这棵树拥有图G中的所有顶点，且所有边都是来自图G中的边，并且满足整棵树的边权之和最小。

（1）最小生成树是一棵树，因此其边数等于顶点数减去1，且树内一定不会有环
（2）对给定的图G(V,E)，最小生成树可能不唯一，但是边权之和一定是唯一的（最小）
（3）因为最小生成树是由无向图生成的，因此其根节点可以是这棵树上的任意一个节点。

2、prim算法求解最小生成树

prim算法 – 普里姆算法

基本思想：对图G(V,E)设置集合S，存放已经被访问的顶点，然后每次从集合V-S（即未被访问的节点集合）中选择与集合S的最短距离最小的一个顶点（记为u）,访问u，并将其加入集合S。之后，令顶点u为中介点，优化所有从u能到达的顶点v与集合S之间的距离。这样的操作执行n次（n为顶点个数），直到集合S已包含所有顶点。

prim算法和Dijsktra算法的思想大致相同，关于Dijkstra算法可以参考：Dijkstra(迪杰斯特拉)算法： 求单源最短路径（C++实现）

以下是使用邻接矩阵实现图，并实现prim算法：

#include <iostream>
using namespace std;

const int MAXV = 1000;
const int INF = 1000000000;

int n; // 顶点个数
int G[MAXV][MAXV]; // 图的邻接矩阵表示
int d[MAXV];     // 记录顶点与集合S的距离，初始化为INF，表示不可达
bool vis[MAXV] = { false }; // 标记数组，true - 表示已访问，即集合S

int prim() {
    fill(d, d + MAXV, INF);
    d[0] = 0; // 默认零号为最小生成树的根节点，也可以选择其他节点作为根节点
    int ans = 0; // 存放最小生成树的边权
    for (int i = 0; i < n; ++i) {
        int u = -1, MIN = INF;
        for (int j = 0; j < n; ++j) {
            if (vis[j] == false && d[j] < MIN) {
                u = j;
                MIN = d[j];
            }
        }
        if (u == -1) return;
        vis[u] = true;
        ans += d[u];  // 将当前与集合S距离最小的边加入最小生成树
        for (int v = 0; v < n; ++v) {
            if (vis[v] == false && G[u][v] != INF && G[u][v] < d[v]) {
                d[v] = G[u][v];  // 以u为中介点可以使v离集合S更近
            }
        }
    }
    return ans; // 返回边的权值
}

以下是使用邻接表实现图，并实现prim算法：

#include <iostream>
#include <vector>
using namespace std;

const int MAXV = 1000;
const int INF = 1000000000;

struct node {
    int v;   // 目标顶点
    int dis; // 边权值
};

int n;  // 顶点个数
int d[MAXV]; // 记录顶点与集合S的距离，初始化为INF，表示不可达
vector<node> adj[MAXV]; // 邻接表实现图
bool vis[MAXV] = { false }; // 用来表示顶点是否被访问，如果已访问，就表示处于集合S中

int prim() {
    fill(d, d + MAXV, INF);
    d[0] = 0;   // 以0号节点作为最小生成树的根节点
    int ans = 0;   // 记录最小生成树的边权之和
    for (int i = 0; i < n; ++i) {
        int u = -1, MIN = INF;
        for (int j = 0; j < n; ++j) {
            if (vis[j] == false && d[j] < MIN) {
                u = j;
                MIN = d[j];
            }
        }
        if (u == -1) return -1; // 说明剩下的节点无法与集合S连通
        vis[u] = true;  // 将当前节点加入集合S中，即已被访问的节点
        ans += d[u];    // 记录边权之和
        for (int j = 0; j < adj[u].size(); ++j) {
            int v = adj[u][j].v;       // 从 u 可以到达的顶点 v
            int dis = adj[u][j].dis;   // u - v 之间的距离
            if (vis[v] == false && dis < d[v]) {
                d[v] = dis; // 以u为中介点，可以使v到集合S的距离减少
            }
        }
    }
    return ans;
}

谢谢阅读

参考《算法笔记》