数据结构与算法-弗洛伊德算法(Floyd)

弗洛伊德算法

• 和Dijkstra算法一样，弗洛伊德算法也是一种用于寻找给定加权图中顶点间最短路径的算法。该算法名称以创始人之一，1978年图灵奖获得者，斯坦福大学计算机科学家教授罗伯特-弗洛伊德命名
• 弗洛伊德算法计算图中各个顶点之间的最短路径
• 迪杰斯特拉算法计算图中某一个顶点到其他顶点间的最短路径
• 佛洛依德算法VS迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问的顶点，求出从出发点到其他顶点的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以需要每一个顶点看作被访问的顶点，求出每个顶点到其他顶点的最短路径。

算法分析

1. 设置顶点vi到顶点vk的最短路径为Lik，顶点vk到vj的最短路径为Lkj，顶点vi到vj的路径为Lij，则vi到vj的最短路径为：min((Lik+Lkj), Lij)，vk的取值为图中所有顶点，则可获得vi到vj得最短路径
2. 至于vi到vk得最短路径Lik或者vk到vj得最短路路径Lkj，是以同样方式获得

代码实现

public class FloydAlgorithm {

	public static void main(String[] args) {
		char[] data = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
		int N = 65535;
		
		int[][] matrix = {
			{    0,      5,     7,     N,     N,     N,     2},
			{    5,      0,     N,     9,     N,     N,     3},
			{    7,      N,     0,     N,     8,     N,     N},
			{    N,      9,     N,     0,     N,     4,     N},
			{    N,      N, 	8,     N,     0,     5, 	4},
			{    N,      N,     N, 	   4, 	  5,     0, 	6},
			{	 2,  	 3,     N, 	   N, 	  4, 	 6,	    0}
		}; 
		
		Graph graph = new Graph(data.length, matrix, data);
		graph.floyd();
		graph.show();
	}

}

class Graph {
	char[] vertex;  //顶点数组
	private int[][] dis;  //保存从各个顶点出发到其他顶点的距离
	private int[][] pre;  //保存到达目标顶点的前驱顶点
	
	
	public void floyd() {
		
		int len = 0;
		
		//对中间点进行遍历，k是中间顶点的下标
		for (int k = 0; k < dis.length; k++) {
			
			//从i顶点出发['A', 'B', 'C', 'D', 'E', 'F', 'G']
			for (int i = 0; i < dis.length; i++) {
				
				for (int j= 0; j < dis.length; j++) {
					len = dis[i][k] + dis[k][j];  //求出从i顶点经过k中间顶点到达j顶点的距离
					if (len < dis[i][j]) {
						dis[i][j] = len;  //更新距离
						pre[i][j] = pre[k][j];  //更新前驱顶点
					}
				}
			}
		}
	}
	
	
	/**
	 * 
	 * @param length  长度
	 * @param matrix  邻接矩阵
	 * @param vertex  顶点数组
	 */
	public Graph(int length, int[][] matrix, char[] vertex) {
		this.vertex = vertex;
		this.dis = matrix;
		this.pre = new int[length][length];
		
		//对pre数组初始化,存放的是前驱顶点的下标
		for (int i = 0; i < length; i++) {
			Arrays.fill(pre[i], i);
		}
	}
	
	public void show() {
		for (int k = 0; k <dis.length; k++) {
			//先将pre数组输出
			for (int i = 0; i <dis.length; i++) {
				System.out.print(pre[k][i] + "  ");
			}
			System.out.println();
		}
		
		System.out.println("----------------------------");
		
		for (int k = 0; k <dis.length; k++) {
			//先将pre数组输出
			for (int i = 0; i <dis.length; i++) {
				System.out.println(vertex[k] + "到" + vertex[i] + "最短路径" + dis[k][i] + "  ");
			}
		}
	}
}
``