AcWing 858. Prim算法求最小生成树(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≤5001≤n≤500,
1≤m≤1051≤m≤105,
图中涉及边的边权的绝对值均不超过10000。

输入样例：

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

输出样例：

6

import java.io.*;
import java.lang.*;
import java.util.*;

class Main{
    
    static int n = 0, m = 0, N = 510;
    static int INF = 0x3f3f3f3f;
    static int[][] g = new int[N][N];
    static boolean[] f = new boolean[N];
    static int[] dist = new int[N];
    static int res = 0;
    static boolean Prim(){
        Arrays.fill(dist, INF);
        for(int i = 1; i <= n; ++i){
            int t = -1;
            for(int j = 1; j <= n; ++j){
                if(!f[j] && (t == -1 || dist[j] < dist[t]))
                    t = j;
            }
            f[t] = true;
            if(i != 1 && dist[t] > INF / 2)return false;
            if(i != 1)res += dist[t];
            for(int j = 1; j <= n; ++j){
                if(dist[j] > g[t][j]){
                    dist[j] = g[t][j];
                }
            }
        }
        return true;
        
    }
    
    public static void main(String[] args)throws Exception{
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        String[] params = buf.readLine().split(" ");
        n = Integer.valueOf(params[0]);
        m = Integer.valueOf(params[1]);
        for(int i = 1; i <= n; ++i)
            for(int j = 1; j <= n; ++j)
                if(i == j)g[i][j] = 0;
                else g[i][j] = INF;
        for(int i = 1; i <= m; ++i){
            String[] info = buf.readLine().split(" ");
            int a = Integer.valueOf(info[0]);
            int b = Integer.valueOf(info[1]);
            int w = Integer.valueOf(info[2]);
            g[a][b]= g[b][a] = Math.min(g[a][b], w);
        }
        if(Prim()){
            System.out.print(res);
        }else{
            System.out.print("impossible");
        }
        
    }
}

import java.io.*;
import java.lang.*;
import java.util.*;

class Main{
    
    static int n = 0, m = 0, N = 510;
    static int[][] edges = new int[N][N];
    static int INF = 0x3f3f3f3f;
    static int[] dist = new int[N];
    static boolean[] f = new boolean[N];
    static int Prim(){
        int res = 0;
        Arrays.fill(dist, INF);
        dist[1] = 0;
        for(int i = 1; i <= n; ++i){
            int t = -1;
            for(int j = 1; j <= n; ++j){
                if(!f[j] && (t == -1 || dist[t] > dist[j])){
                    t = j;
                }
            }
            f[t] = true;
            if(dist[t] > INF / 2)return -1;
            res += dist[t];
            for(int j = 1; j <= n; ++j){
                if(dist[j] > edges[t][j]){
                    dist[j] = edges[t][j];
                }
            }
        }
        return res;
    }
        
    public static void main(String[] args)throws Exception{
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        String[] params = buf.readLine().split(" ");
        n = Integer.valueOf(params[0]);
        m = Integer.valueOf(params[1]);
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                if(i == j)
                    edges[i][j] = 0;
                else
                    edges[i][j] = edges[j][i] = INF;
            }
        }
        for(int i = 1; i <= m; ++i){
            String[] info = buf.readLine().split(" ");
            int u = Integer.valueOf(info[0]);
            int v = Integer.valueOf(info[1]);
            int w = Integer.valueOf(info[2]);
            edges[u][v] = edges[v][u] = Math.min(edges[u][v], w);
        }
        
        int res = Prim();
        System.out.print(res == -1 ? "impossible" : res);
    }
}