Java十大算法之普里姆算法

场景:修路问题

有胜利乡7个村庄(A,B,C,D,E,F,G),现在需要修路把7个村庄连通,各个村庄的距离用边线表示(权),比如A-B距离5公里,问:如何修路保证各个村庄都能连通,并且总的修建公路总里程最短?

先介绍一下最小生成树:
最小生成树(Minimum Cost Spanning Tree),简称MST,给定一个带权的左向连接通图,如何选取一颗生成树,使树上所有边上权的总和为最小,这叫最小生成树,N个顶点,一定有N-1条边,包含全部顶点,N-1条边都在图中,如下图

最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法

1.普里姆算法介绍

普利姆(Prim)算法求最小生成树,也就是在包含n个顶点的连通图中,找出只有(n-1)条边包含所有n个顶点的连通子图,也就是所谓的极小连通子图

普里姆算法如下:
(1)设G=(V,E)是连通网,T=(U,D)是最小生成树,V,U是顶点集合,E,D是边的集合
(2)若从顶点u开始构造最小生成树,则从集合v中取出顶点u放入集合U中,标记顶点v的visited[u] = 1
(3)若集合U中顶点ui与集合V-U中的顶点vj之间存在边,则寻找这些边中权值最小的边,单不能构成回路,将顶点vj加入集合U中,将边(ui,vj)加入集合D中,标记visited[vj]=1
(4)重复步骤2,知道U,V相等,即所有顶点都被标记为访问过,此时D中有n-1条边

如果在再不理解,可以看下面这幅图

步骤分析已经很清晰了,现在我们代码实现

package com.self.tenAlgorithm;



import java.util.Arrays;

public class PrimAlgorithm {
    public static void main(String[] args) {
        char[] data = {'A','B','C','D','E','F','G'};
        int verxs = data.length;
        //邻接矩阵的关系使用二维数组表示   10000这个大数  表示两个点不连通
        int[][] weight = {
                {10000,5,7,10000,10000,10000,2},
                {5,10000,10000,9,10000,10000,3},
                {7,10000,10000,10000,8,10000,10000},
                {10000,9,10000,10000,10000,4,10000},
                {10000,10000,8,10000,10000,5,4},
                {10000,10000,10000,4,5,10000,6},
                {2,3,10000,10000,4,6,10000}
        };
        MGraph mGraph = new MGraph(verxs);
        MinTree minTree = new MinTree();
        minTree.createGraph(mGraph,verxs,data,weight);

        minTree.showGraph(mGraph);

        minTree.prim(mGraph,0);

    }
}
//创建最小生成树  ->村庄的图
class MinTree{
    /**
     * @param graph  图对象
     * @param verxs 图对应的顶点
     * @param data  图的各个顶点的值
     * @param weight  图的邻接矩阵
     */
    public void createGraph(MGraph graph,int verxs,char data[],int[][] weight){
        for (int i = 0; i < verxs; i++) {  //顶点
            graph.data[i] = data[i];
            for (int j = 0; j < verxs; j++) {
                graph.weight[i][j] = weight[i][j];
            }
        }
    }

    /**   显示图的邻接矩阵
     * @param graph
     */
    public void showGraph(MGraph graph){
        for (int[] link : graph.weight) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * @param graph  图
     * @param v  表示从图的第几个顶点开始访问  'A'->0  'B'->2
     */
    public void prim(MGraph graph,int v){
        //标记结点是否被访问过  0表示没有访问过  1表示访问过
        int[] visied = new int[graph.verxs];
        visied[v] = 1;  //当前结点表示已访问
        int h1 = -1;
        int h2 = -1; //h1,h2记录两个顶点的下标
        int minWeight = 10000;
        for (int i = 1; i < graph.verxs; i++) {  //边的数等于顶点的数-1,所以从1开始
            //确定每一次生成的子图,当前顶点和哪个节点近
            for (int j = 0; j < graph.verxs; j++) {  //假设表示被访问过节点
                for (int k = 0; k < graph.verxs; k++) {  //假设表示没有被访问过的节点
                    if(visied[j] == 1 && visied[k] == 0 && graph.weight[j][k] < minWeight){
                        minWeight = graph.weight[j][k];
                        h1 = j;
                        h2 = k;
                    }
                }
            }
            System.out.println(graph.data[h1]+"=="+graph.data[h2]+"=="+minWeight);
            visied[h2] = 1;
            minWeight = 10000;
        }
    }
}
class MGraph{
    int verxs;  //表示图的节点个数
    char[] data;  //存放节点数据
    int[][] weight;  //存放边,就是我们的邻接矩阵
    public MGraph(int verxs){
        this.verxs = verxs;
        data = new char[verxs];
        weight = new int[verxs][verxs];
    }
}