[073] Java “普利姆算法（Prim）”解决“修路问题”

1、问题及算法描述

• 生成树：含有 n 个顶点的连通图可以构成多种生成树，如下图（a）。但最少可用 n-1 条边将所有顶点连接起来，如下图（b）；
• 
• 最小生成树：对带有权值的图，生成树路径中权值总和最小的路径，称为最小生成树。最小生成树的顶点为 n，边为 n-1；
• 修路问题：有7个村庄(A, B, C, D, E, F, G) ，现在需要修路把7个村庄连通，各个村庄的距离用边线表示(权) ，如何修路保证各个村庄都能连通，并且总的修建公路总里程最短?
• 
• Prim（普里姆）算法：
  • ​​​​​​​① <A>顶点开始处理，将< A>顶点和他们相邻的还没有访问的顶点进行处理,找到路径最小的边 <A,G>，权值：2，此时，被访问过的结点为：<A,G>  A-C [7] A-G[2] A-B[5] => A-G[2] 最小；
  • ② <A,G> 开始 , 将<A,G>顶点和他们相邻的还没有访问的顶点进行处理,找到路径最小的边 <G,B> ，权值：3，此时，被访问过的结点为：<A,G,B>  A-C[7] A-B[5] G-B[3] G-E[4] G-F[6] =>G-B[3] 最小；
  • ③ <A,G,B> 开始，将<A,G,B>顶点和他们相邻的还没有访问的顶点进行处理,找到路径最小的边 <G,E> ，权值：4，此时，被访问过的结点为：<A,G,B,E>  A-C[7] G-E[4] G-F[6] B-D[9] =>G-E[4] 最小；
  • ④ <A,G,B,E> 开始，将<A,G,B,E>顶点和他们相邻的还没有访问的顶点进行处理,找到路径最小的边 <E,F> ，权值：5，此时，被访问过的结点为：<A,G,B,E,F>  A-C[7] E-F[5] G-F[6] B-D[9] =>E-F[5] 最小；
  • ⑤ <A,G,B,E,F> 开始，将<A,G,B,E,F>顶点和他们相邻的还没有访问的顶点进行处理,找到路径最小的边 <F,D> ，权值：4，此时，被访问过的结点为：<A,G,B,E,F,D>  A-C[7] E-C[8] F-D[4] B-D[9] =>F-D[4] 最小；
  • ⑥ <A,G,B,E,F,D> 开始，将<A,G,B,E,F,D>顶点和他们相邻的还没有访问的顶点进行处理,找到路径最小的边 <A,C> ，权值：7，此时，被访问过的结点为：<A,G,B,E,F,D,C> A-C[7] E-C[8] B-D[9] =>A-C[7] 最小；
  • 此时，所有的结点都被访问过了，并且连接的路径最小。
  • 

2、Java代码 -- 普利姆算法

package Algorithm.Prim;

import java.util.Arrays;

/**
 * @author bigyang
 * @date 2020/11/04
 */
public class PrimAlgorithm {
    public static void main(String[] args) {
        char[] data = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int verxs = data.length;
        // 使用邻接矩阵（二维数组）表示各村庄之间的距离，用一个很大的数n(10000)表示不连通
        final int n = 10000;
        int[][] weight = new int[][]{
                {n, 5, 7, n, n, n, 2},
                {5, n, n, 9, n, n, 3},
                {7, n, n, n, 8, n, n},
                {n, 9, n, n, n, 4, n},
                {n, n, 8, n, n, 5, 4},
                {n, n, n, 4, 5, n, 6},
                {2, 3, n, n, 4, 6, n},
        };

        // 创建一个村庄集合对象
        MGraph mGraph = new MGraph(verxs);
        // 创建一个最小生成树
        MinTree minTree = new MinTree();
        minTree.createGraph(mGraph, verxs, data, weight);

        // 输出测试
        System.out.println("村庄之间的邻接矩阵为：");
        minTree.showGraph(mGraph);
        System.out.println();

        // 普利姆算法
        System.out.println("普利姆算法输出权值最小的边：");
        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) {
        int i, j;
        // 顶点
        for (i = 0; i < verxs; i++) {
            graph.data[i] = data[i];
            for (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     从图的第几个顶点开始生成，但无论从哪个顶点开始，图的最小生成树的权值是相等的
     */
    public void prim(MGraph graph, int v) {
        // visited标记村庄顶点是否被访问过
        int[] visited = new int[graph.verxs];

        // 把当前这个节点标记为已访问
        visited[v] = 1;
        // 用h1和h2记录两个顶点的下标
        int h1 = -1;
        int h2 = -1;
        // 定义变量记录村庄之间的最小距离
        int minWeight = 10000;
        // 总路径
        int sumWeight = 0;

        // 最小生成树的顶点为n，边为n-1，所以从1开始计数
        for (int k = 1; k < graph.verxs; k++) {
            // 确定每次生成的子图，和哪个节点的距离最近
            // i表示被访问过的节点
            for (int i = 0; i < graph.verxs; i++) {
                // j表示未被访问过的节点
                for (int j = 0; j < graph.verxs; j++) {
                    // 找到最小路径，并替换minWeight
                    if (visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < minWeight) {
                        // 寻找访问过的节点和未被访问过的节点间的权值最小的边
                        minWeight = graph.weight[i][j];
                        h1 = i;
                        h2 = j;
                    }
                }
            }
            // 当找到最小的一个边时
            System.out.println("边：" + graph.data[h1] + " <-> " + graph.data[h2] + "  权值：" + minWeight);
            // 最小路径和
            sumWeight += minWeight;

            // 将当前节点标记为已经访问
            visited[h2] = 1;
            // 重置minWeight
            minWeight = 10000;
        }
        System.out.println();
        System.out.println("连通所有村庄最少需要修建的公路里程为：" + sumWeight);

    }
}

/**
 * 村庄集合对象
 */
class MGraph {
    /**
     * 图的节点的个数
     */
    int verxs;
    /**
     * 存放节点数据
     */
    char[] data;
    /**
     * 存放边，各村庄之间的距离，即邻接矩阵
     */
    int[][] weight;

    /**
     * 构造器
     *
     * @param verxs 节点数
     */
    public MGraph(int verxs) {
        this.verxs = verxs;
        data = new char[verxs];
        weight = new int[verxs][verxs];
    }
}

3、运行结果

村庄之间的邻接矩阵为：
[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]

普利姆算法输出权值最小的边：
边：A <-> G  权值：2
边：G <-> B  权值：3
边：G <-> E  权值：4
边：E <-> F  权值：5
边：F <-> D  权值：4
边：A <-> C  权值：7

连通所有村庄最少需要修建的公路里程为：25