Acwing858_Prim算法求最小生成树

题目

给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|

由 V 中的全部 n 个顶点和 E 中 n?1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。

输入格式

第一行包含两个整数 n 和 m

接下来 m 行，每行包含三个整数 u,v,w，表示点 u 和点 v 之间存在一条权值为 w 的边。

输出格式

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出 impossible。

数据范围

• 1≤n≤105
• 1≤m≤2?105
• 图中涉及边的边权的绝对值均不超过1000

输入样例：

4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4

输出样例：

6

代码与解析

1. 图的表示：使用邻接矩阵g表示无向图的边权。

2. Prim算法思路：

   • 初始化距离数组dis，标记数组state和最小生成树的权值ans。
   • 从任意起始点开始，每次选择一个未访问的节点中距离最小的节点，标记为已访问，并更新与其相邻的节点的距离。
   • 重复上述步骤直至所有节点都被访问，得到最小生成树。

3. 返回值：如果图不连通，则返回max；否则返回最小生成树的权值ans。

注意事项：

• 判断图不连通的条件是当且仅当i > 0（非第一个节点）且当前访问节点的距离为无穷大。
• 为防止整个图不连通，应在每次选择节点之前判断，若已存在访问的节点且当前访问节点的距离为无穷大，则返回max

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    static int n, m, N = 510, max = (int) 1e9;
    static int[][] g = new int[N][N];
    static int[] dis = new int[N];
    static boolean[] state = new boolean[N];

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        
        // 初始化图的邻接矩阵
        for (int i = 0; i <= n; i++) {
            Arrays.fill(g[i], max);
        }
        
        // 读入边的权值，将边权值存入邻接矩阵
        for (int i = 0; i < m; i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            int w = in.nextInt();
            g[u][v] = g[v][u] = Math.min(w, g[u][v]);  // 无向图取边权的最小值
        }
        
        int t = prim();
        if (t == max) {
            System.out.println("impossible");
        } else {
            System.out.println(t);
        }
    }

    /**
     * Prim算法求最小生成树
     * @return 最小生成树的权值，如果不连通返回max
     */
    public static int prim() {
        Arrays.fill(dis, max);  // 初始化距离数组，初始值为无穷大
        int ans = 0;  // 最小生成树的权值

        for (int i = 0; i < n; i++) {
            int t = -1;  // 当前访问的节点
            for (int j = 1; j <= n; j++) {
                // 选择未访问的节点中距离最小的节点
                if (!state[j] && (t == -1 || dis[t] > dis[j])) {
                    t = j;
                }
            }
            state[t] = true;  // 标记节点为已访问

            // 如果是第一个节点，并且距离为无穷大，说明图不连通
            if (i > 0 && dis[t] == max) {
                return max;
            }

            // 累加最小生成树的权值
            if (i > 0) {
                ans += dis[t];
            }

            // 更新与当前节点相邻的节点的距离
            for (int j = 1; j <= n; j++) {
                dis[j] = Math.min(dis[j], g[t][j]);
            }
        }

        return ans;
    }
}