14.7 克鲁斯卡尔算法
14.7.1 应用场景-公交站问题
看一个应用场景和问题:
- 某城市新增 7 个站点(A, B, C, D, E, F, G) ,现在需要修路把 7 个站点连通
- 各个站点的距离用边线表示(权) ,比如 A – B 距离 12 公里
- 问:如何修路保证各个站点都能连通,并且总的修建公路总里程最短?
14.7.2 克鲁斯卡尔算法介绍
- 克鲁斯卡尔(Kruskal)算法,是用来求加权连通图的最小生成树的算法。
- 基本思想:按照权值从小到大的顺序选择 n-1 条边,并保证这 n-1 条边不构成回路
- 具体做法:首先构造一个只含 n 个顶点的森林,然后依权值从小到大从连通网中选择边加入到森林中,并使森林中不产生回路,直至森林变成一棵树为止
14.7.3 克鲁斯卡尔算法图解说明
以城市公交站问题来图解说明 克鲁斯卡尔算法的原理和步骤:
- 在含有 n 个顶点的连通图中选择 n-1 条边,构成一棵极小连通子图,并使该连通子图中 n-1 条边上权值之和达到最小,则称其为连通网的最小生成树。
例如,对于如上图 G4 所示的连通网可以有多棵权值总和不相同的生成树。
克鲁斯卡尔算法对上图进行图解(以上图 G4 为例,来对克鲁斯卡尔进行演示,假设,用数组 R 保存最小生成树结果):
第 1 步:将边加入 R 中。
边的权值最小,因此将它加入到最小生成树结果 R 中。
第 2 步:将边加入 R 中。
上一步操作之后,边的权值最小,因此将它加入到最小生成树结果 R 中。
第 3 步:将边加入 R 中。
上一步操作之后,边的权值最小,因此将它加入到最小生成树结果 R 中。
第 4 步:将边加入 R 中。
上一步操作之后,边的权值最小,但会和已有的边构成回路;因此,跳过边。同理,跳过边。将边加入到最小生成树结果 R 中。
第 5 步:将边加入 R 中。
上一步操作之后,边的权值最小,因此将它加入到最小生成树结果 R 中。
第 6 步:将边加入 R 中。
上一步操作之后,边的权值最小,但会和已有的边构成回路;因此,跳过边。同理,跳过边。将边加入到最小生成树结果 R 中。此时,最小生成树构造完成!它包括的边依次是:<E,F><C,D><D,E><B,F><E,G><A,B>。
- 克鲁斯卡尔算法分析
根据前面介绍的克鲁斯卡尔算法的基本思想和做法,我们能够了解到,克鲁斯卡尔算法重点需要解决的以下两个问题:
问题一: 对图的所有边按照权值大小进行排序。
问题二: 将边添加到最小生成树中时,怎么样判断是否形成了回路。
问题一 很好解决,采用排序算法进行排序即可。
问题二,处理方式是:记录顶点在"最小生成树"中的终点,顶点的终点是"在最小生成树中与它连通的最大顶点"。然后每次需要将一条边添加到最小生存树时,判断该边的两个顶点的终点是否重合,重合的话则会构成回路。
- 如何判断是否构成回路----举例说明(如图)
在将 加入到最小生成树 R 中之后,这几条边的顶点就都有了终点:
(01) C 的终点是 F。
(02) D 的终点是 F。
(03) E 的终点是 F。
(04) F 的终点是 F。
关于终点的说明:
- 就是将所有顶点按照从小到大的顺序排列好之后;某个顶点的终点就是"与它连通的最大顶点"。
- 因此,接下来,虽然是权值最小的边。但是C 和 E 的终点都是F,即它们的终点相同,因此,将<C,E>加入最小生成树的话,会形成回路。这就是判断回路的方式。也就是说,我们加入的边的两个顶点不能都指向同一个终点,否则将构成回路。【后面有代码说明】
14.7.4 克鲁斯卡尔最佳实践-公交站问题
看一个公交站问题:
- 有北京有新增 7 个站点(A, B, C, D, E, F, G) ,现在需要修路把 7 个站点连通
- 各个站点的距离用边线表示(权) ,比如 A – B 距离 12 公里
- 问:如何修路保证各个站点都能连通,并且总的修建公路总里程最短?
- 代码实现和注解
import java.util.Arrays;
/**
* @author zk
* @version 1.0.0
* @ClassName KruskalCase.java
* @Description TODO 克鲁斯卡尔最佳实践-公交站问题(如何修路保证各个站点都能连通,并且总的修建公路总里程最短?)
* @createTime 2021年09月30日 16:24:00
*/
public class KruskalCase {
private int edgeNum; // 边的个数
private char[] vertex; // 顶点的个数
private int[][] matrix; // 邻接矩阵
private static final int INF = Integer.MAX_VALUE;
public static void main(String[] args) {
char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
//克鲁斯卡尔算法的邻接矩阵
int matrix[][] = {
/*A*//*B*//*C*//*D*//*E*//*F*//*G*/
/*A*/ { 0, 12, INF, INF, INF, 16, 14},
/*B*/ { 12, 0, 10, INF, INF, 7, INF},
/*C*/ { INF, 10, 0, 3, 5, 6, INF},
/*D*/ { INF, INF, 3, 0, 4, INF, INF},
/*E*/ { INF, INF, 5, 4, 0, 2, 8},
/*F*/ { 16, 7, 6, INF, 2, 0, 9},
/*G*/ { 14, INF, INF, INF, 8, 9,0}};
KruskalCase kruskalCase = new KruskalCase(vertex, matrix);
kruskalCase.kruskal();
}
public void kruskal(){
// 用于保存"已有最小生成树" 中的每个顶点在最小生成树中的终点
int[] ends = new int[edgeNum];
// 用于保存最小生生成树
EData[] result = new EData[edgeNum];
// 存数据的时候做下表
int index = 0;
// 获取到所有边
EData[] edges = getEdges();
// 根据权值 从小到大排序
sortEdge(edges);
for (int i = 0; i < edgeNum; i++) {
// 获取一条边的第一个顶点的下表
int p1 = getPosition(edges[i].start);
// 获取一条边的第二条顶点的下表
int p2 = getPosition(edges[i].end);
int m = getEnd(ends,p1);
int n = getEnd(ends,p2);
if (m!=n){
ends[m] = n;
result[index++] = edges[i];
}
}
for (int i = 0; i < index; i++) {
System.out.print(result[i]);
}
}
public int getEnd(int[] ends,int i){
while (ends[i] !=0){
i = ends[i];
}
return i;
}
// 构造器
public KruskalCase(char[] vertex,int[][] matrix){
int vLen = vertex.length;
this.vertex = new char[vLen];
for (int i = 0; i < vertex.length; i++) {
this.vertex[i] = vertex[i];
}
this.matrix = new int[vLen][vLen];
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
this.matrix[i][j] = matrix[i][j];
}
}
for (int i = 0; i < matrix.length; i++) {
for (int j = i+1; j < matrix[i].length; j++) {
// 统计边的个数
if (this.matrix[i][j]!=INF){
this.edgeNum++;
}
}
}
}
public void print(){
for (int i = 0; i < this.matrix.length; i++) {
for (int j = 0; j < this.matrix[i].length; j++) {
System.out.printf("%12d",this.matrix[i][j]);
}
System.out.println();
}
}
/**
* 功能:对边进行排序处理, 冒泡排序
* @param edges 边的集合
*/
private void sortEdge(EData[] edges){
for (int i = 0; i < edges.length-1; i++) {
for (int j = 0; j < edges.length - 1 - i; j++) {
if (edges[j].weight > edges[j+1].weight){
EData tmp = edges[j];
edges[j] = edges[j+1];
edges[j+1] = tmp;
}
}
}
}
/**
*
* @param ch 顶点的值,比如'A','B' * @return 返回 ch 顶点对应的下标,如果找不到,返回-1
*/
public int getPosition(char ch){
for (int i = 0; i < vertex.length; i++) {
if (vertex[i]==ch){
return i;
}
}
return -1;
}
/**
* 功能: 获取图中边,放到 EData[] 数组中,后面我们需要遍历该数组
* 是通过 matrix 邻接矩阵来获取
* EData[] 形式 [['A','B', 12], ['B','F',7], .....]
* @return
*/
private EData[] getEdges(){
int index = 0;
EData[] edges = new EData[edgeNum];
for (int i = 0; i < vertex.length; i++) {
for (int j = i+1; j < vertex.length; j++) {
if (matrix[i][j]!=INF){
edges[index++] = new EData(vertex[i],vertex[j],matrix[i][j]);
}
}
}
return edges;
}
}
class EData{
char start; //边的一个点
char end; //边的另一个点
int weight; //边的权值
// 构造器
public EData(char start, char end, int weight) {
this.start = start;
this.end = end;
this.weight = weight;
}
@Override
public String toString() {
return "EData{" +
"<" + start +
"," + end +
">=" + weight +
'}';
}
}