二十八、搜素与图论——朴素 Prim 算法（最小生成树算法）

一、基本思路

1、目标与基本概念

• 目标问题：
• • 多个城市中铺公路，使城市之间可以相互联通，问如何才能让铺设公路的长度最短——铺设的路径即为最小生成树。
• 基本概念：
• • dis[] 数组：表示1~n个点到集合的距离；
• • 集合：即为已经加入的最小生成树的点与边的集合；
• • 到集合的距离大小：（如下图所示）

2、Prim 算法步骤 O(n^2 + m)

• 算法步骤：

dis[] <--- 正无穷
for(int i = 0; i < n; i++)		// 表示需要遍历 n 次才可以将整个图都连通
	t = -1;		// 表明还没有找到到集合最小距离的点
	t <--- 找到  集合外  距离最近的点（把t加入集合）			O（n）
	st[t] = true; 		// 表明这个点已经加入集合中
	用 t 来更新其他点到 集合 的距离（用st[j]来进行校验，为了防止出现自环）	O（mlogn）

• 举例：

3、注意

• 1. 最小生成树不可以把自环（尤其是负环）加入，会导致更新距离出错；
• 2. 寻找距离集合最近的点

int t = -1;         // 表明还没有找到距离集合最短的点
            
// 此处是用来寻找距离 集合 最近的点的
for(int j = 1; j <= n; j++){
    if(st[j] == false &&(t == -1 || dis[j] < dis[t])){
      t = j;
      }
}

二、Java、C语言模板实现

//Java 模板实现
static int[][] g = new int[N][N];
static int[] dis = new int[N];              // 此处存储的是各个点到最小生成树集合的距离，而不是1到n的距离
static boolean[] st = new boolean[N];       // 判断是否加入自环
    
    
static int Prim(){
        
    dis[1] = 0;
    int res = 0;
        
    for(int i = 1; i <= n; i++){            // 循环n次才可能把每个点都尽可能加入集合
            
       int t = -1;         // 表明还没有找到距离集合最短的点
            
            // 此处是用来寻找距离 集合 最近的点的
       for(int j = 1; j <= n; j++){
           if(st[j] == false &&(t == -1 || dis[j] < dis[t])){
              t = j;
              }
        }
            
     if(dis[t] == INF) return INF;       // 如果找到的最近的点是无穷大，说明之间没有通路，也就无法构成最小生成树 
            
     res += dis[t];              // 记录每个点逐渐加入走过集合的最短路径，最终合成最小生成树
            
     st[t] = true;               // 表示已经加入集合
            
     for(int j = 1; j <= n; j++){
     	if(st[j] == false){         // 只更新没在集合中的点，后续还要在这些点中继续加树
        //上述的st判断，还有一个很重要的作用是————可以去掉自负环，因为使用t来更新自己的时候，会发现st已经变成true了
                    
        // 注意此处的最小值更新与Dijkstra不同，Dijkstra是dis【t】 + g【t】【j】，dis是1到n距离
        // 在prim算法中dis是到集合的距离，因此只需要找到点j通过t是否可以更新到集合的最短距离
              dis[j] = Math.min(dis[j], g[t][j]);
        }
	}
        // 注意此处的更新，一定要在res+=dis【t】前面，因为，若存在自环，就会出现问题，导致一直在自己身上转悠
    }
        
    return res;
}

```cpp
// C++语言实现，此处是yxc实现
int n;      // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中


// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if (i && dist[t] == INF) return INF;

        if (i) res += dist[t];
        st[t] = true;

        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}

三、例题题解

// java题解实现
import java.util.*;

public class Main{
    static int N = 510;
    static int INF = 0x3f3f3f3f;
    static int n,m;
    static int x,y,c;
    
    static int[][] g = new int[N][N];
    static int[] dis = new int[N];              // 此处存储的是各个点到最小生成树集合的距离，而不是1到n的距离
    static boolean[] st = new boolean[N];       // 判断是否加入自环
    
    
    static int Prim(){
        
        dis[1] = 0;
        int res = 0;
        
        for(int i = 1; i <= n; i++){            // 循环n次才可能把每个点都尽可能加入集合
            
            int t = -1;         // 表明还没有找到距离集合最短的点
            
            // 此处是用来寻找距离 集合 最近的点的
            for(int j = 1; j <= n; j++){
                if(st[j] == false &&(t == -1 || dis[j] < dis[t])){
                    t = j;
                }
            }
            
            if(dis[t] == INF) return INF;       // 如果找到的最近的点是无穷大，说明之间没有通路，也就无法构成最小生成树 
            
            res += dis[t];              // 记录每个点逐渐加入走过集合的最短路径，最终合成最小生成树
            
            st[t] = true;               // 表示已经加入集合
            
            for(int j = 1; j <= n; j++){
                if(st[j] == false){         // 只更新没在集合中的点，后续还要在这些点中继续加树
                //上述的st判断，还有一个很重要的作用是————可以去掉自负环，因为使用t来更新自己的时候，会发现st已经变成true了
                    
                    // 注意此处的最小值更新与Dijkstra不同，Dijkstra是dis【t】 + g【t】【j】，dis是1到n距离
                    // 在prim算法中dis是到集合的距离，因此只需要找到点j通过t是否可以更新到集合的最短距离
                    dis[j] = Math.min(dis[j], g[t][j]);
                }
            }
            // 注意此处的更新，一定要在res+=dis【t】前面，因为，若存在自环，就会出现问题，导致一直在自己身上转悠

        }
        
        return res;
    }
    
    
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        
        n = in.nextInt();
        m = in.nextInt();
        Arrays.fill(dis, INF);
        
        for(int i = 0; i < N; i++){         // 因为可能存在重边，因此设置为最大，为了配合后面的Math.min(g[x][y],c)操作
           Arrays.fill(g[i],INF); 
        }
        
        
        for(int i = 0; i < m; i++){
            x = in.nextInt();
            y = in.nextInt();
            c = in.nextInt();
            g[x][y] = Math.min(g[x][y],c);      // 无向图，双向
            g[y][x] = g[x][y];
        }
        
        
        int result = Prim();
        
        if(result == INF){
            System.out.println("impossible");
        }else{
            System.out.println(result);
        }
        
    }
}