【数据结构与算法】普里姆算法的介绍和修路问题程序实现

1. 最小生成树的介绍

最小生成树(Minimum Cost Spanning Tree)，简称MST。给定一个带权的无向连通图, 选取一棵生成树, 生成树所有顶点都能连通但不能形成回路。使树上所有边的权的总和为最小, 就是最小生成树。如下所示：

所以N个顶点，一定有N-1条边

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

2. 普里姆算法的介绍

普利姆(Prim)算法求最小生成树，就是在包含N个顶点的完全图中，找出只有(N-1)条边且包含所有N个顶点的最小总权重值的连通子图

思路如下：

1. 对于第一顶点，直接标记为已访问
2. 找出所有边，其中一个顶点已访问，另一个顶点未访问。取权重值最小的一条边，并将该条边的未访问的顶点标记为已访问
3. 不断的重复步骤2，直到所有顶点都被访问

3. 修路问题的介绍

问题：有7个村庄A、B、C、D、E、F、G，各个村庄之间的距离(权)用边线表示，比如A -> B距离5公里。如何让各个村庄都能连通，并且总的修路里程最短

基本思路：尽可能少的选择路线，并且选择的路线距离最短，才能保证总的修路里程数最短

程序如下：

import java.util.Arrays;

public class PrimAlgorithm {

    public static void main(String[] args) {
        // 顶点集合
        char[] vertexs = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        // 顶点个数
        int vertexNum = vertexs.length;

        // N个顶点形成的N * N二维数组，用来保存顶点之间的距离
        // 用10000表示距离无限大，不能连通
        int[][] weights = 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}
        };

        // 创建Graph对象
        Graph graph = new Graph(vertexNum);
        graph.addData2Graph(vertexs, weights);
        // 输出weights
        graph.showWeights();

        // 创建MinTree对象
        MinTree minTree = new MinTree();

        // 测试普利姆算法
        minTree.prim(graph, 1);
    }

}

// 图
class Graph {
    // 顶点个数
    int vertexNum;
    // 顶点集合
    char[] vertexs;
    // N个顶点形成的N * N二维数组，用来保存顶点之间的距离
    int[][] weights;

    // 进行初始化，但并未向数组保存值
    public Graph(int vertexNum) {
        this.vertexNum = vertexNum;
        this.vertexs = new char[vertexNum];
        this.weights = new int[vertexNum][vertexNum];
    }

    // 向图的数组保存值
    public void addData2Graph(char[] vertexs, int[][] weights) {
        for (int i = 0; i < this.vertexNum; i++) {
            this.vertexs[i] = vertexs[i];
            for (int j = 0; j < this.vertexNum; j++) {
                this.weights[i][j] = weights[i][j];
            }
        }
    }

    // 显示图的二维数组，即显示顶点之间的距离
    public void showWeights() {
        for (int[] line : this.weights) {
            System.out.println(Arrays.toString(line));
        }
    }
}

// 创建最小生成树
class MinTree {

    // prim算法实现，生成最小生成树
    // vertexIndex表示顶点在vertexs的index
    public void prim(Graph graph, int vertexIndex) {
        // 用来标记顶点是否被访问过。初始化都是未访问的0
        int[] visited = new int[graph.vertexNum];
        for (int i = 0; i < visited.length; i++) {
            visited[i] = 0;
        }

        // 当前这个结点标记为已访问
        visited[vertexIndex] = 1;

        // 临时的已访问的顶点index，和临时的未访问的顶点index
        int tmpVisitedVertexIndex = -1;
        int tmpNotVisitedVertexIndex = -1;
        // 初始化minWeight为一个大数，在遍历过程中，会被赋予较小的权重值
        int minWeight = 10000;

        // 每一次遍历，都能找到一个满足条件的顶点，和一条满足条件的边
        for (int k = 1; k < graph.vertexNum; k++) {

            // 进行双层for循环处理
            for (int i = 0; i < graph.vertexNum; i++) {
                for (int j = 0; j < graph.vertexNum; j++) {
                    // 第一层for循环表示已访问的顶点, 第二层for循环表示未访问的顶点
                    // 如果当前边的权重值，比minWeight还小，则找到了一条更优的边
                    if (visited[i] == 1 && visited[j] == 0 && graph.weights[i][j] < minWeight) {
                        minWeight = graph.weights[i][j];

                        // 更优的边的两个顶点的index
                        tmpVisitedVertexIndex = i;
                        tmpNotVisitedVertexIndex = j;
                    }
                }
            }

            // 遍历完成，就会找到一条权重值最小的边
            System.out.println("找到的边<" + graph.vertexs[tmpVisitedVertexIndex] + " -> " + graph.vertexs[tmpNotVisitedVertexIndex] + ">, 权重值为: " + minWeight);

            // 将找到的未访问的顶点，标记为已访问
            visited[tmpNotVisitedVertexIndex] = 1;

            // 再次将minWeight重置
            minWeight = 10000;
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

运行程序，结果如下：

[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]
找到的边 G>, 权重值为: 3
找到的边 A>, 权重值为: 2
找到的边 E>, 权重值为: 4
找到的边 F>, 权重值为: 5
找到的边 D>, 权重值为: 4
找到的边 C>, 权重值为: 7
1
2
3
4
5
6
7
8
9
10
11
12
13