数据结构与算法-Prim算法解析与解决修路最小生成树问题

简介

Prim算法

​ 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克发现；并在1957年由美国计算机科学家罗伯特·普里姆）独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法(引自百度百科)。

最小生成树

​ 普利姆(Prim)算法主要应用在求最小生成树问题(克鲁斯卡尔算法也适用于这种问题，**prim**算法适合稠密图，其时间复杂度为O(n^2)，其时间复杂度与边得数目无关，而**kruskal**算法的时间复杂度为O(nlogn)跟边的数目有关，适合稀疏图)，给定一张边带权的无向图 G = ( V, E ), n=| V |, m=| E |。由 V 中全部 n 个顶点和 E 中 n-1 条边构成的无向连通子图被称为 G 的一棵生成树。边的权值之和最小的生成树被称为无向图 G 的最小生成树 （ Minimum Spanning Tree, MST ) 。任意一棵最小生成树一定包含无向图中权值最小的边。

应用场景

问题描述

​ 有7个村庄(A, B, C, D, E, F, G) ，现在需要修路把7个村庄连通，各个村庄的距离用边线表示(权) ，比如 A – B 距离 5公里，问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短?
​ 思路: 将10条边，连接即可，但是总的里程数不是最小，正确的思路，就是尽可能的选择少的路线，并且每条路线最小，保证总里程数最少。

思路分析

1.从A顶点开始处理 => <A,G> 2
A-C [7] A-G[2] A-B[5]
2.<A,G> 开始 , 将A 和 G 顶点和他们相邻的还没有访问的顶点进行处理 =><A,G,B>
A-C[7] A-B[5] G-B[3] G-E[4] G-F[6]
3.<A,G,B> 开始，将A,G,B 顶点 和他们相邻的还没有访问的顶点进行处理=><A,G,B,E>
A-C[7] G-E[4] G-F[6] B-D[9]
…
4.{A,G,B,E}->F//第4次大循环 ， 对应边<E,F> 权值：5
5.{A,G,B,E,F}->D//第5次大循环 ， 对应边<F,D> 权值：4
6.{A,G,B,E,F,D}->C//第6次大循环 ， 对应边<A,C> 权值：7 => <A,G,B,E,F,D,C>

代码实现

import java.util.Arrays;

public class PrimAlgorithm {

    public static void main(String[] args) {
        char[] data = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int num = data.length;
        // 邻接矩阵的关系使用二维数组表示，使用10000这个比较大的数值表示两点不连通
        int[][] weight = new int[][]{
                {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 graph = new MGraph(num);
        // 创建一个minTree对象
        MinTree minTree = new MinTree();
        minTree.createGraph(graph, num, data, weight);
        // 打印图
        minTree.showGraph(graph);
        minTree.prim(graph, 0);
    }

    static class MGraph {
        // 表示图的节点数量
        int num;
        // 存放节点数据
        char[] data;
        // 存放边，即邻接矩阵
        int[][] weight;

        public MGraph(int num) {
            this.num = num;
            this.data = new char[num];
            this.weight = new int[num][num];
        }
    }

    // 最小生成树->村庄的图
    static class MinTree {

        /**
         * 创建图的邻接矩阵
         *
         * @param graph  图
         * @param num    图对应的节点数量
         * @param data   图的各个节点的值
         * @param weight 图的邻接矩阵
         */
        public void createGraph(MGraph graph, int num, char[] data, int[][] weight) {
            // int i, j;
            for (int i = 0; i < num; i++) {
                graph.data[i] = data[i];
                for (int j = 0; j < num; j++) {
                    graph.weight[i][j] = weight[i][j];
                }
            }
        }

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

        /**
         * prim算法，得到最小生成树
         *
         * @param graph 图
         * @param v     表示从图的第几个节点开始生成'A'->0 'B'->1 ...
         */
        public void prim(MGraph graph, int v) {
            // 标记节点是否被访问过
            int[] visited = new int[graph.num];
            // 把当前节点标记为已访问
            visited[v] = 1;
            // 使用h1和h2记录两个节点的下标
            int h1 = -1;
            int h2 = -2;
            // 记录最小距离，将minWeight初始成一个大数，后面遍历过程中会被替换
            int minWeight = 10000;
            // 因为有graph.num个节点，普利姆算法结束后，有graph.num-1条边
            for (int k = 1; k < graph.num; k++) {
                // 确定每一次生成的子图，和哪个节点的距离最近
                // i节点表示被访问过的节点
                for (int i = 0; i < graph.num; i++) {
                    // j节点表示没被访问过的节点
                    for (int j = 0; j < graph.num; j++) {
                        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);
                // 将当前这个节点标记为已访问
                visited[h2] = 1;
                // minWeight重新设置为最大值 10000
                minWeight = 10000;
            }
        }
    }

}

输出结果：

[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
 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