核心思想:
通过Floyd计算图G=(V,E)中各个顶点的最短路径时,需要引入一个矩阵S,矩阵S中的元素a[i][j]表示顶点i(第i个顶点)到顶点j(第j个顶点)的距离。假设图G中顶点个数为N,则需要对矩阵S进行N次更新。 初始时,矩阵S中顶点a[i][j]的距离为顶点i到顶点j的权值;如果i和j不相邻,则a[i][j]=∞。接下来开始,对矩阵S进行N次更新。第1次更新时,如果"a[i][j]的距离" > "a[i][0]+a[0][j]"(a[i][0]+a[0][j]表示"i与j之间经过第1个顶点的距离"),则更新a[i][j]为"a[i][0]+a[0][j]"。同理,第k次更新时,如果"a[i][j]的距离" > "a[i][k]+a[k][j]",则更新a[i][j]为"a[i][k]+a[k][j]"。更新N次之后,操作完成!
过程图解:
代码:
package com.smart.reflect;
import java.io.IOException;
import java.util.Scanner;
public class MatrixUDG {
private int mEdgNum; // 边的数量
private char[] mVexs; // 顶点集合
private int[][] mMatrix; // 邻接矩阵
private static final int INF = Integer.MAX_VALUE; // 最大值
/*
* 创建图(自己输入数据)
*/
public MatrixUDG() {
// 输入"顶点数"和"边数"
System.out.printf("input vertex number: ");
int vlen = readInt();
System.out.printf("input edge number: ");
int elen = readInt();
if (vlen < 1 || elen < 1 || (elen > (vlen * (vlen - 1)))) {
System.out.printf("input error: invalid parameters!\n");
return;
}
// 初始化"顶点"
mVexs = new char[vlen];
for (int i = 0; i < vlen; i++) {
System.out.printf("vertex(%d): ", i);
mVexs[i] = readChar();
}
// 1. 初始化"边"的权值
mEdgNum = elen;
mMatrix = new int[vlen][vlen];
for (int i = 0; i < vlen; i++) {
for (int j = 0; j < vlen; j++) {
if (i == j)
mMatrix[i][j] = 0;
else
mMatrix[i][j] = INF;
}
}
// 2. 初始化"边"的权值: 根据用户的输入进行初始化
for (int i = 0; i < elen; i++) {
// 读取边的起始顶点,结束顶点,权值
System.out.printf("edge(%d):", i);
char c1 = readChar(); // 读取"起始顶点"
char c2 = readChar(); // 读取"结束顶点"
int weight = readInt(); // 读取"权值"
int p1 = getPosition(c1);
int p2 = getPosition(c2);
if (p1 == -1 || p2 == -1) {
System.out.printf("input error: invalid edge!\n");
return;
}
//无向图可以当成是两条边的有向图
mMatrix[p1][p2] = weight;
mMatrix[p2][p1] = weight;
}
}
/*
* 创建图(用已提供的矩阵)
*
* 参数说明:
* vexs -- 顶点数组
* matrix-- 矩阵(数据)
*/
public MatrixUDG(char[] vexs, int[][] matrix) {
// 初始化"顶点数"和"边数"
int vlen = vexs.length;
// 初始化"顶点"
mVexs = new char[vlen];
for (int i = 0; i < vlen; i++)
mVexs[i] = vexs[i];
// 初始化"边"
mMatrix = new int[vlen][vlen];
for (int i = 0; i < vlen; i++)
for (int j = 0; j < vlen; j++)
mMatrix[i][j] = matrix[i][j];
// 统计"边"---这里针对的是无向图
mEdgNum = 0;
for (int i = 0; i < vlen; i++)
for (int j = i + 1; j < vlen; j++)
if (mMatrix[i][j] != INF)
mEdgNum++;
}
/*
* 返回字符在数组中的位置
*/
private int getPosition(char ch) {
for (int i = 0; i < mVexs.length; i++)
if (mVexs[i] == ch)
return i;
return -1;
}
/*
* 读取一个输入字符
*/
private char readChar() {
char ch = '0';
do {
try {
ch = (char) System.in.read(); //注意其用法 一定要加上while条件判断 否则就会出错
} catch (IOException e) {
e.printStackTrace();
}
} while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
return ch;
}
/*
* 读取一个输入整数
*/
private int readInt() {
Scanner scanner = new Scanner(System.in);
return scanner.nextInt();
}
/*
* floyd最短路径。
* 即,统计图中各个顶点间的最短路径。
*
* 参数说明:
* path -- 路径。path[i][j]=k表示,"顶点i"到"顶点j"的最短路径会经过顶点k。
* dist -- 长度数组。即,dist[i][j]=sum表示,"顶点i"到"顶点j"的最短路径的长度是sum。
*/
public void floyd(int[][] path, int[][] dist) {
int vlen = mVexs.length;//顶点数
// 初始化
for (int i = 0; i < vlen; i++) {
for (int j = 0; j < vlen; j++) {
dist[i][j] = mMatrix[i][j]; // "顶点i"到"顶点j"的路径长度为"i到j的权值"。
path[i][j] = j; // "顶点i"到"顶点j"的最短路径是经过顶点j。
}
}
// 计算最短路径
for (int k = 0; k < vlen; k++) {
for (int i = 0; i < vlen; i++) {
for (int j = 0; j < vlen; j++) {
// 如果经过下标为k顶点路径比原两点间路径更短,则更新dist[i][j]和path[i][j]
int tmp = (dist[i][k] == INF || dist[k][j] == INF) ? INF : (dist[i][k] + dist[k][j]);
if (dist[i][j] > tmp) { //如果有多条路径值相等,则保留最初的一条
// "i到j最短路径"对应的值设,为更小的一个(即经过k)
dist[i][j] = tmp;
// "i到j最短路径"对应的路径,经过k
path[i][j] = path[i][k];
}
}
}
}
// 打印floyd最短路径的结果
System.out.printf("floyd: \n");
for (int i = 0; i < vlen; i++) {
for (int j = 0; j < vlen; j++)
System.out.printf("%2d ", dist[i][j]);
System.out.printf("\n");
}
}
//打印floyd最短路径的具体路径 path[A][D]=F 没有E输出 因此需要递归
//路径只有两种情况 要不就是ABI(B和I是相连通的) 要不就是AB......I(B和I之间还有需要元素)
public void Pfloyd(int a, int b, int path[][]) {
System.out.print(mVexs[a] + " ");
// if (mMatrix[path[a][b]][b] == INF) //原数组没有变化
// {
// Pfloyd(path[a][b], b, path);
// }else{
// System.out.print(mVexs[path[a][b]]+" "+mVexs[b]);
// }
int x=path[a][b];
while(x!=b){
System.out.print(mVexs[x]+" ");
x=path[x][b];
}
System.out.print(mVexs[x]);
}
public static void main(String[] args) {
char[] vexs = {'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, 10000, 2, 0, 9},
/*G*/ {14, INF, INF, INF, 8, 9, 0}};
MatrixUDG pG;
// 自定义"图"(输入矩阵队列)
//pG = new MatrixUDG();
// 采用已有的"图"
pG = new MatrixUDG(vexs, matrix);
int[][] path = new int[pG.mVexs.length][pG.mVexs.length];
int[][] floy = new int[pG.mVexs.length][pG.mVexs.length];
// floyd算法获取各个顶点之间的最短距离
pG.floyd(path, floy);
//输出任意两点之间最短路径长度以及其路径 这里不考虑输入节点相同的情况 太简单了
System.out.println("请输入任意两节点:");
int a = pG.getPosition(pG.readChar());
int b = pG.getPosition(pG.readChar());
System.out.println("两节点之间最短路径长度为:" + floy[a][b]);
System.out.print("两节点之间路径为:");
pG.Pfloyd(a, b, path);
}
}