2020/11/09 最小生成树-克鲁斯卡尔算法

题目

给定一个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

源代码

import java.util.*;
class Main{
    static int n;
    static int m;
    static int N=100010;
    static int M=200010;
    static int[] p=new int[N];
    static Edge[] edges=new Edge[M];
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        for(int i=0;i<m;i++){
            int a=sc.nextInt();
            int b=sc.nextInt();
            int w=sc.nextInt();
            edges[i]=new Edge(a,b,w);
        }
        int res=kruscal();
        if(res==-1) System.out.print("impossible");
        else System.out.print(res);
        
    }
    public static int find(int x){
        if(p[x]!=x) p[x]=find(p[x]);
        return p[x];
    }
    public static int kruscal(){
        Arrays.sort(edges,0,m-1);
        int res=0;
        int count=0;
        for(int i=1;i<=n;i++){
            p[i]=i;
        }
        for(int i=0;i<m;i++){
            int a=edges[i].a;
            int b=edges[i].b;
            int w=edges[i].w;
            a=find(a);//每条边的结点直接找祖宗节点,操作的也是祖宗节点
            b=find(b);
            if(a!=b){
                p[a]=b;
                count++;
                res+=w;
            }
        }
        if(count<n-1) return -1;
        return res;
    }
}
class Edge implements Comparable<Edge>{
    int a,b,w;
    public Edge(int a,int b,int w){
        this.a=a;
        this.b=b;
        this.w=w;
    }
    public int compareTo(Edge o){
        return Integer.compare(this.w,o.w);
    }
}

算法解析

类似于最短路径算法分为对边的遍历和对节点的遍历
prim算法其实就是节点的遍历,加入集合更新
而kruscal算法就是对边的遍历,但是就不再是更新其他边了,而是对所有边进行排序,从小到大来连接节点(点亮边),如果一条边的两个结点属于两个连通域,则把他们连接上;如果属于一个,则直接跳过这条边.
因为要进行排序的操作,所以需要使用排序算法(Arrays.sort即可)
而由于有判断是否属于连通域的算法,我们就可以使用并查集,通过查找节点的祖宗节点是否相同来判断是否为同一连通域.
并查集模板:

//初始化每个节点的父节点都是自己
...

int  find(int x){//并查集核心,找到结点的祖宗结点
 if(p[x]!=x) p[x]=find(p[x]);
 return p[x];