0 修路问题
- 有胜利乡有 7 个村庄(A, B, C, D, E, F, G) ，现在需要修路把 7 个村庄连通
- 各个村庄的距离用边线表示(权) ，比如 A – B 距离 5 公里
- 问：如何修路保证各个村庄都能连通，并且总的修建公路总里程最短?
思路: 将 10 条边，连接即可，但是总的里程数不是最小. 正确的思路，就是尽可能的选择少的路线，并且每条路线最小，保证总里程数最少.
1 最小生成树
- 修路问题本质就是就是最小生成树问题
- 最小生成树(Minimum Cost Spanning Tree)，简称 MST,给定一个带权的无向连通图,如何选取一棵生成树,使树上所有边上权的总和为最小,这叫最小生成树
- MST特征:N 个顶点,一定有 N-1 条边,包含全部顶点,N-1 条边都在图中,如下图
- 求最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法
2 普里姆算法
宏观理解:
- 选择任一顶点A作为起始点
- 选择A周围可直连且未访问过的顶点中距离最近的,G点,标记为已访问
- 对已访问的顶点A和G,分别执行第2步,得到下一个顶点B并标记已访问
- 重复执行第3步直到已访问顶点数涵盖所有图顶点
- 得到最小生成树
微观理解:
- 代码核心为内外三层for循环,辅助工具为2个指针i、j,以及访问情况数组visited
- 最外层for表示需要选择几轮顶点才能得到最小生成树
- 中间层for用于使指针i指向已访问顶点
- 最内层for用于使指针j指向未访问顶点
- 遍历过程中如果顶点i和j间的边为本轮最短,则得到本轮最短路径
- 最终所有最短路径,及其经过的顶点,就是最小生成树
//普利姆算法:修路问题,最小生成树
public class PrimAlgorithm {
public static void main(String[] args) {
char[] data = new char[]{'A','B','C','D','E','F','G'};
int verxs = 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},};
MinTree tree = new MinTree();
MGraph mGraph = new MGraph(verxs);
tree.createGraph(mGraph, verxs, data, weight);
tree.showGraph(mGraph);
tree.prim(mGraph,0);
}
}
//最小生成树
class MinTree {
//构建邻接矩阵
public void createGraph(MGraph mGraph, int verxs, char[] data, int[][] weight) {
for (int i = 0; i < verxs; i++) {
mGraph.data[i] = data[i];
for (int j = 0; j < verxs; j++) {
mGraph.weight[i][j] = weight[i][j];
}
}
}
//展示邻接矩阵
public void showGraph(MGraph mGraph) {
for (int i = 0; i < mGraph.verxs; i++) {
System.out.println(Arrays.toString(mGraph.weight[i]));
}
}
//得到最小生成树
public void prim(MGraph graph, int v) {
//数组标记经过的顶点
int[] visited = new int[graph.verxs];
visited[v] = 1;
//两个指针存放经过的顶点,和周围未经过的顶点
int h1 = -1;
int h2 = -1;
//n和顶点需要n-1条路连接,因此需要修n-1轮路
for (int k = 1; k < graph.verxs; k++) {
//存放本轮的最短修路长
int minWeight = 10000;
for (int i = 0; i < graph.verxs; i++) {
for (int j = 0; j < graph.verxs; j++) {
//围绕经过的顶点和周围未经过的顶点找最短路径
if (visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < minWeight) {
minWeight = graph.weight[i][j];
h1 = i;
h2 = j;
}
}
}
//标记通路的新顶点为已读
visited[h2] = 1;
System.out.println("第"+k+"轮修路"+graph.data[h1]+"-"+graph.data[h2]+"路长"+minWeight);
}
}
}
//图
class MGraph {
int verxs;//顶点数
char[] data;//顶点集
int[][] weight;//邻接矩阵
public MGraph(int verxs) {
this.verxs = verxs;
data = new char[verxs];
weight = new int[verxs][verxs];
}
}
3 克鲁斯卡尔算法
- 如果说普里姆算法的重心在于看顶点,那么克鲁斯卡尔算法的中心在于看边,不断使用权值最小加入到最小生成树中
- 首先,拿到所有边,对边按权值升序排序,开始遍历所有边
- 选择权值最小的边EF,再取剩余边中最小的边CD
- 重点来了,检验当前选取的边是否构成了回路(闭环),没有回路,继续
- 取剩余边中最小的边DE,仍然没有构成回路,继续
- 取剩余边中最小的边CF,构成回路,那么说明CF不可取,扔掉(因为CF边没有给最小生成树带来新的顶点)
- 继续选取不会构成回路的边,直到所有边遍历结束
//克鲁斯卡尔算法:公交站问题,最小生成树
public class KruskalCase {
private int edgeNum; //边的个数
private char[] vertexs; //顶点数组
private int[][] matrix; //邻接矩阵
//使用 INF 表示两个顶点不能连通
private static final int INF = Integer.MAX_VALUE;
public static void main(String[] args) {
char[] vertexs = {'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 tree = new KruskalCase(vertexs, matrix);
tree.print();
tree.kruskal();
}
//构造器
public KruskalCase(char[] vertexs, int[][] matrix) {
this.vertexs = vertexs;
this.matrix = matrix;
for (int i = 0; i < matrix.length; i++) {
for (int j = i + 1; j < matrix[i].length; j++) {
if (matrix[i][j] != INF) {
edgeNum++;
}
}
}
}
//重点
public void kruskal() {
//获得所有边并排序
EData[] edges = getEdges();
sortEdges(edges);
//结果集
int index = 0;
EData[] res = new EData[vertexs.length - 1];
//存放的并不一定是终点,很有可能是后继节点的索引,而数组本身的索引就对应顶点
int[] ends = new int[vertexs.length];
Arrays.fill(ends, -1);
for (int i = 0; i < edges.length; i++) {
//边的两端顶点
int start = getPosition(edges[i].start);//4
int end = getPosition(edges[i].end);//5
//两个顶点的终点
int m = getEnd(ends, start);//4
int n = getEnd(ends, end);//5
//为什么这里用m和n而不用start和end?m替换成start也不行吗?
//1.因为后者的方式会导致ends的元素值被覆盖,导致判断错误,结果错误,结果集索引越界
// 比如修eg时,end[4]的值由5改为g的下标6,导致之前的cde的终点f改为g,导致错修fg
// 其实这里的终点也并不是路的尽头,而是路上所有顶点中(下标)最大的
//2.本操作说简单点,就是让新的终点放在旧的终点的后面,
// 用start代替m,同样会导致1中的问题,
// end数组中的轨迹并不是路的轨迹,而是从曾经的终点跳到另一个新的终点,比如end[3]=5
if (m != n) {
res[index++] = edges[i];
ends[m] = n;
}
}
System.out.println(Arrays.toString(res));
}
//打印邻接矩阵
public void print() {
for (int[] ints : matrix) {
for (int i : ints) {
System.out.printf("%12d", i);
}
System.out.println();
}
}
//对边数组冒泡排序
public void sortEdges(EData[] edges) {
EData temp = null;
for (int i = 0; i < edges.length - 1; i++) {
for (int j = 0; j < edges.length - i - 1; j++) {
if (edges[j].weight > edges[j + 1].weight) {
temp = edges[j];
edges[j] = edges[j + 1];
edges[j + 1] = temp;
}
}
}
}
//返回顶点下标
public int getPosition(char ch) {
for (int i = 0; i < vertexs.length; i++) {
if (ch == vertexs[i]) {
return i;
}
}
return -1;
}
//收集图中所有边
public EData[] getEdges() {
EData[] edges = new EData[edgeNum];
int index = 0;
for (int i = 0; i < matrix.length; i++) {
for (int j = i + 1; j < matrix[i].length; j++) {
if (matrix[i][j] != INF) {
edges[index++] = new EData(vertexs[i], vertexs[j], matrix[i][j]);
}
}
}
return edges;
}
//获取顶点的终点下标,这里初始化ends为元素-1的数组而不是0避免与顶点a同义
//注意:ends数组虽然存放的可能只是后继节点/终点,但genEnd方法得到的一定是终点(自己也算)
public int getEnd(int[] ends, int i) {
//我理解这里ends存放的并不一定是终点,很有可能是后继节点的索引,而数组本身的索引就对应顶点
while (ends[i] != -1) {
i = ends[i];
}
return i;
}
}
//边对象
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;
}
//重写 toString, 便于输出边信息
@Override
public String toString() {
return "EData [<" + start + ", " + end + ">= " + weight + "]";
}
}
