数据结构与算法--最短路径之Floyd算法
数据结构与算法--最短路径之Floyd算法
我们知道Dijkstra算法只能解决单源最短路径问题,且要求边上的权重都是非负的。有没有办法解决任意起点到任意顶点的最短路径问题呢?如果用Dijkstra算法,可以这样做:
Dijkstra[] all = new Dijkstra[graph.vertexNum()];
for (int i = 0; i < all.length; i++) {
all[i] = new Dijkstra(graph, i);
}
for (int s = 0; s < all.length; s++) {
for (int i = 0; i < graph.vertexNum(); i++) {
System.out.print(s + " to " + i + ": ");
System.out.print("(" + all[s].distTo(i) + ") ");
System.out.println(all[s].pathTo(i));
}
System.out.println();
}
其实就是有n个顶点,创建了n个实例对象,每个实例传入了不同的参数而已。我们想要一次性得到任意起点到任意顶点的最短路径集合,可以尝试Floyd算法。
解决多源最短路径的Floyd算法
首先,Floyd算法可以处理负权边,但是不能处理负权回路,也就是类似 a -> b -> c ->a,a -> b、b -> c、c -> a三条边的权值和为负数。因为只要我们一直围着这个环兜圈子,就能得到权值和任意小的路径!负权回路会使得最短路径的概念失去意义!
Floyd算法需要两个二维矩阵,因此使用邻接矩阵实现的有向加权图最为方便,不过我一直用邻接表实现的。为此需要将邻接表转换为相应的邻接矩阵。很简单,先将整个二维数组用0和正无穷填充,对角线上权值为0,其余位置正无穷。然后将邻接表中的元素覆盖原数组中对应位置的值,这样邻接表就转换为邻接矩阵了。邻接矩阵在代码中我们用dist[][]
表示,这里面存放的就是任意顶点到其他顶点的最短路径!另外需要另外一个二维数组edge[][]
,像edge[v][w]
存放的是v到w的路径中途经的某一个顶点(或叫中转点),具体来说edge[v][w]
表示v -> w这条路径上到w的前一个顶点。v -> w途径的顶点可能有多个,都在v那一行即edge[v][i]
里找。
算法的精华在下面几行:
if (dist[v][k] + dist[k][w] < dist[v][w]) {
dist[v][w] = dist[v][k] + dist[k][w];
edge[v][w] = edge[k][w];
}
其中k是v -> w路径中途径的某一个顶点,判断条件其实和Dijkstra的判断条件如出一辙,即:到底是原来v -> w的路径比较短;还是先由v经过k,再从k到w的这条路径更短,如果是后者,那么需要更新相关数据结构。Floyd依次把图中所有顶点都当做一次中转点,判断任意顶点经过该中转点后,路径会不会变得更短。
先放代码...
package Chap7;
import java.util.LinkedList;
import java.util.List;
public class Floyd {
private double[][] dist;
private int[][] edge;
public Floyd(EdgeWeightedDiGraph<?> graph) {
dist = new double[graph.vertexNum()][graph.vertexNum()];
edge = new int[graph.vertexNum()][graph.vertexNum()];
// 将邻接表变成了邻接矩阵
for (int i = 0; i < dist.length; i++) {
for (int j = 0; j < dist.length; j++) {
// 赋值给
edge[i][j] = i;
if (i == j) {
dist[i][j] = 0.0;
} else {
dist[i][j] = Double.POSITIVE_INFINITY;
}
}
}
for (int v = 0; v < graph.vertexNum(); v++) {
for (DiEdge edge : graph.adj(v)) {
int w = edge.to();
dist[v][w] = edge.weight();
}
}
for (int k = 0; k < graph.vertexNum(); k++) {
for (int v = 0; v < dist.length; v++) {
for (int w = 0; w < dist.length; w++) {
if (dist[v][k] + dist[k][w] < dist[v][w]) {
dist[v][w] = dist[v][k] + dist[k][w];
edge[v][w] = edge[k][w];
}
}
}
}
}
public boolean hasPathTo(int s, int v) {
return dist[s][v] != Double.POSITIVE_INFINITY;
}
public Iterable<Integer> pathTo(int s, int v) {
if (hasPathTo(s, v)) {
LinkedList<Integer> path = new LinkedList<>();
for (int i = v; i != s; i = edge[s][i]) {
path.push(i);
}
// 起点要加入
path.push(s);
return path;
}
return null;
}
public double distTo(int s, int w) {
return dist[s][w];
}
public static void main(String[] args) {
List<String> vertexInfo = List.of("v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7");
int[][] edges = {{4, 5}, {5, 4}, {4, 7}, {5, 7}, {7, 5}, {5, 1}, {0, 4}, {0, 2},
{7, 3}, {1, 3}, {2, 7}, {6, 2}, {3, 6}, {6, 0}, {6, 4}};
double[] weight = {0.35, 0.35, 0.37, 0.28, 0.28, 0.32, 0.38, 0.26, 0.39, 0.29,
0.34, 0.40, 0.52, 0.58, 0.93};
EdgeWeightedDiGraph<String> graph = new EdgeWeightedDiGraph<>(vertexInfo, edges, weight);
Floyd floyd = new Floyd(graph);
for (int s = 0; s < graph.vertexNum(); s++) {
for (int w = 0; w < graph.vertexNum(); w++) {
System.out.print(s + " to " + w + ": ");
System.out.print("(" + floyd.distTo(s, w) + ") ");
System.out.println(floyd.pathTo(s, w));
}
System.out.println();
}
}
}
关键的地方就是那三个嵌套for循环了,最外层k一定是中转点,第二层是路径的起点v, 第三层是路径的终点w, 它们是这样的关系 v -> k -> w。v -> w途中可能有多个顶点,k可能只是其中一个。k = 0时,对所有经过0的路径,都更新为当前的最短路径,注意是当前,也就是说是暂时的,随着最外层k的循环,dist[][]
和edge[][]
也会不断发生变化;当k = 1时需要用到刚k = 0更新后的dist[][]
和edge[][]
的状态,也就是说每一轮k的循环都是以上一轮为基础的,到最后一次循环结束,对于经过任意顶点的的所有路径都已是最短路径。可以看出这其实是一个动态规划(DP)问题。
关于路径的存放edge[][]
,有两句代码很关键
// 初始化中
edge[i][j] = i;
// if条件中
edge[v][w] = edge[k][w];
edge[v][w]
存放的是v -> w路径中,终点w的前一个顶点。其实和深度优先和广度优先里用到的edgeTo[]
差不多,这里的edge[][]
对于任意一条v -> w的路径都是一个树形结构,从终点w开始不断往上找其父结点,最后到根结点(即起点v)处停止。edge[i][j] = i;
一开始初始化为起点i的值。意思是i -> j路径中到j的前一个顶点就是i。也就是说我们先假设不经过任何其他顶点的从v到w的直接路径是最短的。在之后的循环中,如果经过其他顶点的i -> j更短就更新;否则就保持默认值。我们将看到,这样初始化在edge[v][w] = edge[k][w]
这句中也适用。
[0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2, 2]
[3, 3, 3, 3, 3, 3, 3, 3]
[4, 4, 4, 4, 4, 4, 4, 4]
[5, 5, 5, 5, 5, 5, 5, 5]
[6, 6, 6, 6, 6, 6, 6, 6]
[7, 7, 7, 7, 7, 7, 7, 7]
- 我们知道v -> k -> w的路径中,v -> k已经是最短路径了,所以只需要更新v -> w,从代码中也可以看出来,我们确实是只对
dist[v][w]
和edge[v][w]
操作。但为什么是edge[v][w] = edge[k][w]
?现在v -> k -> w这条路径更短,k -> w中到w的前一个顶点也就是v -> w路径中到w的前一个顶点。结合edge[v][w]
的定义:存放的是v -> w路径中,w的前一个顶点,可得到edge[v][w] = edge[k][w]
。画个图加深理解。
下图是v -> w第一次更新时:k - > w中到w的前一个顶点应该是k,同时它也是v -> w路径中到w的前一个顶点。所以edge[k][w]
应该为k。而事实确实是这样的!因为在初始化时候我们是这样做的edge[i][j] = i
。
edge[v][w] = edge[k][w] = k
,这里其实就是用了初始值而已。
再看下图,是若干次更新v -> w时,此时v -> k和k -> w路径中可能有多个顶点,但是edge[k][w]
存的始终是终点w的前一个顶点。当v -> w的最短路径更新后,k -> w中到w的前一个顶点就是v -> w路径中到w的前一个顶点。
这就解释了edge[v][w] = edge[k][w]
是怎么来的。
最后得到的edge[][]
如下:
[0, 5, 0, 7, 0, 4, 3, 2]
[6, 1, 6, 1, 6, 7, 3, 2]
[6, 5, 2, 7, 5, 7, 3, 2]
[6, 5, 6, 3, 6, 7, 3, 2]
[6, 5, 6, 7, 4, 4, 3, 4]
[6, 5, 6, 1, 5, 5, 3, 5]
[6, 5, 6, 7, 6, 7, 6, 2]
[6, 5, 6, 7, 5, 7, 3, 7]
by @sunhaiyu
2017.9.24
数据结构与算法--最短路径之Floyd算法的更多相关文章
- 数据结构与算法--最短路径之Bellman算法、SPFA算法
数据结构与算法--最短路径之Bellman算法.SPFA算法 除了Floyd算法,另外一个使用广泛且可以处理负权边的是Bellman-Ford算法. Bellman-Ford算法 假设某个图有V个顶点 ...
- 数据结构与算法--最短路径之Dijkstra算法
数据结构与算法--最短路径之Dijkstra算法 加权图中,我们很可能关心这样一个问题:从一个顶点到另一个顶点成本最小的路径.比如从成都到北京,途中还有好多城市,如何规划路线,能使总路程最小:或者我们 ...
- 图的最短路径---弗洛伊德(Floyd)算法浅析
算法介绍 和Dijkstra算法一样,Floyd算法也是为了解决寻找给定的加权图中顶点间最短路径的算法.不同的是,Floyd可以用来解决"多源最短路径"的问题. 算法思路 算法需要 ...
- Floyd-Warshall算法,简称Floyd算法
Floyd-Warshall算法,简称Floyd算法,用于求解任意两点间的最短距离,时间复杂度为O(n^3). 使用条件&范围通常可以在任何图中使用,包括有向图.带负权边的图. Floyd-W ...
- 一步步学算法(算法分析)---6(Floyd算法)
Floyd算法 Floyd算法又称为弗洛伊德算法,插点法,是一种用于寻找给定的加权图中顶点间最短路径的算法.该算法名称以创始人之一.1978年图灵奖获得者.斯坦福大学计算机科学系教授罗伯特·弗洛伊德命 ...
- 最短路径 - 弗洛伊德(Floyd)算法
为了能讲明白弗洛伊德(Floyd)算法的主要思想,我们先来看最简单的案例.图7-7-12的左图是一个简单的3个顶点的连通网图. 我们先定义两个二维数组D[3][3]和P[3][3], D代表顶点与顶点 ...
- 最短路径之Floyd算法
Floyd算法又称弗洛伊德算法,也叫做Floyd's algorithm,Roy–Warshall algorithm,Roy–Floyd algorithm, WFI algorithm. Floy ...
- 最短路径问题——floyd算法
floyd算法和之前讲的bellman算法.dijkstra算法最大的不同在于它所处理的终于不再是单源问题了,floyd可以解决任何点到点之间的最短路径问题,个人觉得floyd是最简单最好用的一种算法 ...
- 最短路径---Dijkstra/Floyd算法
1.Dijkstra算法基础: 算法过程比prim算法稍微多一点步骤,但思想确实巧妙也是贪心,目的是求某个源点到目的点的最短距离,总的来说dijkstra也就是求某个源点到目的点的最短路,求解的过程也 ...
随机推荐
- lost+found目录有啥用?
Linux系统中根目录下或者新挂载的磁盘目录下有一个叫lost+found,它的作用是什么? 如果你运行fsck命令(文件系统检查和修复命令),它也许会找到一些数据碎片,这些文件碎片在硬盘中并没有引用 ...
- MariaDB 备份与日志管理(13)
MariaDB数据库管理系统是MySQL的一个分支,主要由开源社区在维护,采用GPL授权许可MariaDB的目的是完全兼容MySQL,包括API和命令行,MySQL由于现在闭源了,而能轻松成为MySQ ...
- C++调用API获取当前时间
#include <string> #include<iostream> #include<windows.h> #include <sstream> ...
- D3.js(v3)+react框架 基础部分之数据绑定及其工作过程与绑定顺序
数据绑定: 将数据绑定到Dom上,是D3最大的特色.d3.select和d3.selectAll返回的元素的选择集.选择集上是没有数据的. 数据绑定就是使被选择元素里“含有”数据. 相关函数有两个: ...
- Vue2.5开发去哪儿网App 第五章笔记 下
1. 多个元素或组件的过渡 多个元素的过渡: <style> .v-enter,.v-leace-to{ opacity: 0; } .v-enter-active,.v-leave-ac ...
- 55.storm 之 hello word(本地模式)
strom hello word 概述 然后卡一下代码怎么实现的: 编写数据源类:Spout.可以使用两种方式: 继承BaseRichSpout类 实现IRichSpout接口 主要需要实现或重写几个 ...
- 09-02 java 多态
多态的前提.多态的特点 /* 多态:同一个对象(事物),在不同时刻体现出来的不同状态. 举例: 猫是猫,猫是动物. 水(液体,固体,气态). 多态的前提: A:要有继承关系. B:要有方法重写. 其实 ...
- odoo开发笔记 -- wkhtmltox打印不显示中文 --ubuntu字体安装
wkhtmltox 是一个开源的将网页内容转换成PDF的软件包,常嵌套在网页页面里边做打印功能. 以微软雅黑字体为例(其他的宋体.黑体等点阵字体都一样的),我们的雅黑字体文件是:Yahei.ttf(放 ...
- c# winform as3相互调用
C#主要代码: 首先要添加COM组件-Shockwave Flash Object //接收flash发送过来的信息 private void axShockwaveFlash1_Fla ...
- 全网最详细的Hadoop HA集群启动后,两个namenode都是standby的解决办法(图文详解)
不多说,直接上干货! 解决办法 因为,如下,我的Hadoop HA集群. 1.首先在hdfs-site.xml中添加下面的参数,该参数的值默认为false: <property> < ...