prim算法的实现

prim 算法干的事情是：给定一个无向图，在图中选择若干条边把图的所有节点连起来。要求边长之和最小。在图论中，叫做求最小生成树。

prim 算法采用的是一种贪心的策略。

每次将离连通部分的最近的点和点对应的边加入的连通部分，连通部分逐渐扩大，最后将整个图连通起来，并且边长之和最小。

我们将图中各个节点用数字 1 ~ n 编号。

要将所有景点连通起来，并且边长之和最小，步骤如下：

用一个 state 数组表示节点是否已经连通。state[i] 为真，表示已经连通，state[i] 为假，表示还没有连通。初始时，state 各个元素为假。即所有点还没有连通。
用一个 dist 数组保存各个点到连通部分的最短距离，dist[i] 表示 i 节点到连通部分的最短距离。初始时，dist 数组的各个元素为无穷大。
用一个 pre 数组保存节点的是和谁连通的。pre[i] = k 表示节点 i 和节点 k 之间需要有一条边。初始时，pre 的各个元素置为 -1。

从 1 号节点开始扩充连通的部分，所以 1 号节点与连通部分的最短距离为 0，即disti[1] 置为 0。

遍历 dist 数组，找到一个还没有连通起来，但是距离连通部分最近的点，假设该节点的编号是 i。i节点就是下一个应该加入连通部分的节点，stata[i] 置为 1。
用青色点表示还没有连通起来的点，红色点表示连通起来的点。
这里青色点中距离最小的是 dist[1]，因此 state[1] 置为 1。

遍历所有与 i 相连但没有加入到连通部分的点 j，如果 j 距离连通部分的距离大于 i j 之间的距离，即 dist[j] > w[i][j]（w[i][j] 为 i j 节点之间的距离），则更新 dist[j] 为 w[i][j]。这时候表示，j 到连通部分的最短方式是和 i 相连，因此，更新pre[j] = i。
与节点 1 相连的有 2， 3， 4 号节点。1->2 的距离为 100，小于 dist[2]，dist[2] 更新为 100，pre[2] 更新为1。1->4 的距离为 140，小于 dist[4]，dist[4] 更新为 140，pre[2] 更新为1。1->3 的距离为 150，小于 dist[3]，dist[3] 更新为 150，pre[3] 更新为1。

重复 3 4步骤，直到所有节点的状态都被置为 1.
这里青色点中距离最小的是 dist[2]，因此 state[2] 置为 1。

与节点 2 相连的有 5， 4号节点。2->5 的距离为 80，小于 dist[5]，dist[5] 更新为 80，pre[5] 更新为 2。2->4 的距离为 80，小于 dist[4]，dist[4] 更新为 80，pre[4] 更新为2。

选dist[4]，更新dist[3]，dist[5]，pre[3]，pre[5]。

选dist[5]，没有可更新的。

选dist[3]，没有可更新的。

此时 dist 数组中保存了各个节点需要修的路长，加起来就是。pre 数组中保存了需要选择的边。

伪代码

int dist[n],state[n],pre[n];
dist[1] = 0;
for(i : 1 ~ n)
{
t <- 没有连通起来，但是距离连通部分最近的点;
state[t] = 1;
更新 dist 和 pre;
}
代码

//2022.6.1 更新

#include
#include
#include
using namespace std;

const int N = 510;
int g[N][N];//存储图
int dt[N];//存储各个节点到生成树的距离
int st[N];//节点是否被加入到生成树中
int pre[N];//节点的前去节点
int n, m;//n 个节点，m 条边

void prim()
{
memset(dt,0x3f, sizeof(dt));//初始化距离数组为一个很大的数（10亿左右）
int res= 0;
dt[1] = 0;//从 1 号节点开始生成
for(int i = 0; i < n; i++)//每次循环选出一个点加入到生成树
{
int t = -1;
for(int j = 1; j <= n; j++)//每个节点一次判断
{
if(!st[j] && (t == -1 || dt[j] < dt[t]))//如果没有在树中，且到树的距离最短，则选择该点
t = j;
}

    //2022.6.1 发现测试用例加强后，需要判断孤立点了
    //如果孤立点，直返输出不能，然后退出
    if(dt[t] == 0x3f3f3f3f) {
        cout << "impossible";
        return;
    }


    st[t] = 1;// 选择该点
    res += dt[t];
    for(int i = 1; i <= n; i++)//更新生成树外的点到生成树的距离
    {
        if(dt[i] > g[t][i] && !st[i])//从 t 到节点 i 的距离小于原来距离，则更新。
        {
            dt[i] = g[t][i];//更新距离
            pre[i] = t;//从 t 到 i 的距离更短，i 的前驱变为 t.
        }
    }
}

cout << res;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

}

void getPath()//输出各个边
{
for(int i = n; i > 1; i–)//n 个节点，所以有 n-1 条边。

{
    cout << i <<" " << pre[i] << " "<< endl;// i 是节点编号，pre[i] 是 i 节点的前驱节点。他们构成一条边。
}
1
2
3

}

int main()
{
memset(g, 0x3f, sizeof(g));//各个点之间的距离初始化成很大的数
cin >> n >> m;//输入节点数和边数
while(m --)
{
int a, b, w;
cin >> a >> b >> w;//输出边的两个顶点和权重
g[a][b] = g[b][a] = min(g[a][b],w);//存储权重
}

prim();//求最下生成树
//getPath();//输出路径
return 0;
1
2
3

}

优化

上面代码的时间复杂度为 O(n^2)。

与Dijkstra类似，Prim算法也可以用堆优化，优先队列代替堆，优化的Prim算法时间复杂度O(mlogn)。适用于稀疏图，但是稀疏图的时候求最小生成树，Kruskal 算法更加实用。

画图不易，求个点赞~~