最短路径算法(floyd算法)
2014-11-13 10:10
393 查看
Floyd算法是求解最短路径的动态规划算法。Floyd算法可以说是Warshall算法的扩展,三个for循环就可以解决问题,所以它的时间复杂度为O(n^3)。
Floyd算法的基本思想如下:从任意节点A到任意节点B的最短路径不外乎2种可能,1是直接从A到B,2是从A经过若干个节点X到B。所以,我们假设Dis(AB)为节点A到节点B的最短路径的距离,对于每一个节点X,我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立,如果成立,证明从A到X再到B的路径比A直接到B的路径短,我们便设置Dis(AB) = Dis(AX) + Dis(XB),这样一来,当我们遍历完所有节点X,Dis(AB)中记录的便是A到B的最短路径的距离。很简单吧,代码看起来可能像下面这样:
但是这里我们要注意循环的嵌套顺序,如果把检查所有节点X放在最内层,那么结果将是不正确的,为什么呢?因为这样便过早的把i到j的最短路径确定下来了,而当后面存在更短的路径时,已经不再会更新了。让我们来看一个例子,看下图:
但是这里我们要注意循环的嵌套顺序,如果把检查所有节点X放在最内层,那么结果将是不正确的,为什么呢?因为这样便过早的把i到j的最短路径确定下来了,而当后面存在更短的路径时,已经不再会更新了。
让我们来看一个例子,看下图:
图中红色的数字代表边的权重。如果我们在最内层检查所有节点X,那么对于A->B,我们只能发现一条路径,就是A->B,路径距离为9。而这显然是不正确的,真实的最短路径是A->D->C->B,路径距离为6。造成错误的原因就是我们把检查所有节点X放在最内层,造成过早的把A到B的最短路径确定下来了,当确定A->B的最短路径时Dis(AC)尚未被计算。所以,我们需要改写循环顺序,如下:
这样一来,对于每一个节点X,我们都会把所有的i到j处理完毕后才继续检查下一个节点。
那么接下来的问题就是,我们如何找出最短路径呢?这里需要借助一个辅助数组Path,它是这样使用的:Path(AB)的值如果为P,则表示A节点到B节点的最短路径是A->...->P->B。这样一来,假设我们要找A->B的最短路径,那么就依次查找,假设Path(AB)的值为P,那么接着查找Path(AP),假设Path(AP)的值为L,那么接着查找Path(AL),假设Path(AL)的值为A,则查找结束,最短路径为A->L->P->B。
那么,如何填充Path的值呢?很简单,当我们发现Dis(AX) + Dis(XB) < Dis(AB)成立时,就要把最短路径改为A->...->X->...->B,而此时,Path(XB)的值是已知的,所以,Path(AB) = Path(XB)。
package algorithm;
import java.util.ArrayList;
//
public class Floyd {
public static int M = Integer.MAX_VALUE;
public static int MAXSUM(int a,int b){
return (a!=M&&b!=M)?(a+b):M;
}
public static ArrayList<Integer[][]> flody(Integer[][] dist){
Integer[][] path=new Integer[6][6];//存储的是从i->j经过的最后一个节点
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
path[i][j]=i;
}
}
for(int k=0;k<6;k++){
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
if(dist[i][j]>MAXSUM(dist[i][k], dist[k][j])){
path[i][j]=path[k][j];//存储的是从i->j经过的最后一个节点
dist[i][j]=MAXSUM(dist[i][k], dist[k][j]);
}
}
}
}
ArrayList<Integer[][]> list =new ArrayList<Integer[][]>();
list.add(dist);
list.add(path);
return list;
}
public static Integer[] reverse(Integer[] chain,int count){
int temp;
for(int i=0,j=count-1;i<j;i++,j--){
temp=chain[i];
chain[i]=chain[j];
chain[j]=temp;
}
return chain;
}
public static void display_path(ArrayList<Integer[][]> list){
Integer[][] dist=list.get(0);
Integer[][] path=list.get(1);
Integer[] chain=new Integer[6];
System.out.println("orign->dist"+" dist "+" path");
for (int i = 0; i <6; i++) {
for (int j = 0; j < 6; j++) {
if(i!=j){//只是避免了vi->vi的输出
//输出源到目的地
System.out.print("\n "+(i)+"->"+(j)+" ");
//输出最短路径的长度
if(dist[i][j]==M){
System.out.print(" NA ");
}else{
System.out.print(dist[i][j]+" ");
int count=0;
int k=j;
do {
k=chain[count++]=path[i][k];
} while (i!=k);
chain=reverse(chain,count);
//输出路径
System.out.print(chain[0]+"");
for(k=1;k<count;k++){
System.out.print("->"+(chain[k]));
}
System.out.print("->"+j);
}
}
}
}
}
public static void main(String[] args) {
Integer[][] dist = {
{ 0, 1, 4, M, M, M },
{ 1, 0, 2, 7, 5, M },
{ 4, 2, 0, M, 1, M },
{ M, 7, M, 0, 3, 2 },
{ M, 5, 1, 3, 0, 6 },
{ M, M, M, 2, 6, 0 } };// 建立一个权值矩阵
ArrayList<Integer[][]> list=flody(dist);
display_path(list);
}
}
感谢:http://www.cnblogs.com/twjcnblog/archive/2011/09/07/2170306.html
Floyd算法的基本思想如下:从任意节点A到任意节点B的最短路径不外乎2种可能,1是直接从A到B,2是从A经过若干个节点X到B。所以,我们假设Dis(AB)为节点A到节点B的最短路径的距离,对于每一个节点X,我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立,如果成立,证明从A到X再到B的路径比A直接到B的路径短,我们便设置Dis(AB) = Dis(AX) + Dis(XB),这样一来,当我们遍历完所有节点X,Dis(AB)中记录的便是A到B的最短路径的距离。很简单吧,代码看起来可能像下面这样:
for ( int i = 0; i < 节点个数; ++i ) { for ( int j = 0; j < 节点个数; ++j ) { for ( int k = 0; k < 节点个数; ++k ) { if ( Dis[i][k] + Dis[k][j] < Dis[i][j] ) { // 找到更短路径 Dis[i][j] = Dis[i][k] + Dis[k][j]; } } } }
但是这里我们要注意循环的嵌套顺序,如果把检查所有节点X放在最内层,那么结果将是不正确的,为什么呢?因为这样便过早的把i到j的最短路径确定下来了,而当后面存在更短的路径时,已经不再会更新了。让我们来看一个例子,看下图:
但是这里我们要注意循环的嵌套顺序,如果把检查所有节点X放在最内层,那么结果将是不正确的,为什么呢?因为这样便过早的把i到j的最短路径确定下来了,而当后面存在更短的路径时,已经不再会更新了。
让我们来看一个例子,看下图:
图中红色的数字代表边的权重。如果我们在最内层检查所有节点X,那么对于A->B,我们只能发现一条路径,就是A->B,路径距离为9。而这显然是不正确的,真实的最短路径是A->D->C->B,路径距离为6。造成错误的原因就是我们把检查所有节点X放在最内层,造成过早的把A到B的最短路径确定下来了,当确定A->B的最短路径时Dis(AC)尚未被计算。所以,我们需要改写循环顺序,如下:
for ( int k = 0; k < 节点个数; ++k ) { for ( int i = 0; i < 节点个数; ++i ) { for ( int j = 0; j < 节点个数; ++j ) { if ( Dis[i][k] + Dis[k][j] < Dis[i][j] ) { // 找到更短路径 Dis[i][j] = Dis[i][k] + Dis[k][j]; } } } }
这样一来,对于每一个节点X,我们都会把所有的i到j处理完毕后才继续检查下一个节点。
那么接下来的问题就是,我们如何找出最短路径呢?这里需要借助一个辅助数组Path,它是这样使用的:Path(AB)的值如果为P,则表示A节点到B节点的最短路径是A->...->P->B。这样一来,假设我们要找A->B的最短路径,那么就依次查找,假设Path(AB)的值为P,那么接着查找Path(AP),假设Path(AP)的值为L,那么接着查找Path(AL),假设Path(AL)的值为A,则查找结束,最短路径为A->L->P->B。
那么,如何填充Path的值呢?很简单,当我们发现Dis(AX) + Dis(XB) < Dis(AB)成立时,就要把最短路径改为A->...->X->...->B,而此时,Path(XB)的值是已知的,所以,Path(AB) = Path(XB)。
package algorithm;
import java.util.ArrayList;
//
public class Floyd {
public static int M = Integer.MAX_VALUE;
public static int MAXSUM(int a,int b){
return (a!=M&&b!=M)?(a+b):M;
}
public static ArrayList<Integer[][]> flody(Integer[][] dist){
Integer[][] path=new Integer[6][6];//存储的是从i->j经过的最后一个节点
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
path[i][j]=i;
}
}
for(int k=0;k<6;k++){
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
if(dist[i][j]>MAXSUM(dist[i][k], dist[k][j])){
path[i][j]=path[k][j];//存储的是从i->j经过的最后一个节点
dist[i][j]=MAXSUM(dist[i][k], dist[k][j]);
}
}
}
}
ArrayList<Integer[][]> list =new ArrayList<Integer[][]>();
list.add(dist);
list.add(path);
return list;
}
public static Integer[] reverse(Integer[] chain,int count){
int temp;
for(int i=0,j=count-1;i<j;i++,j--){
temp=chain[i];
chain[i]=chain[j];
chain[j]=temp;
}
return chain;
}
public static void display_path(ArrayList<Integer[][]> list){
Integer[][] dist=list.get(0);
Integer[][] path=list.get(1);
Integer[] chain=new Integer[6];
System.out.println("orign->dist"+" dist "+" path");
for (int i = 0; i <6; i++) {
for (int j = 0; j < 6; j++) {
if(i!=j){//只是避免了vi->vi的输出
//输出源到目的地
System.out.print("\n "+(i)+"->"+(j)+" ");
//输出最短路径的长度
if(dist[i][j]==M){
System.out.print(" NA ");
}else{
System.out.print(dist[i][j]+" ");
int count=0;
int k=j;
do {
k=chain[count++]=path[i][k];
} while (i!=k);
chain=reverse(chain,count);
//输出路径
System.out.print(chain[0]+"");
for(k=1;k<count;k++){
System.out.print("->"+(chain[k]));
}
System.out.print("->"+j);
}
}
}
}
}
public static void main(String[] args) {
Integer[][] dist = {
{ 0, 1, 4, M, M, M },
{ 1, 0, 2, 7, 5, M },
{ 4, 2, 0, M, 1, M },
{ M, 7, M, 0, 3, 2 },
{ M, 5, 1, 3, 0, 6 },
{ M, M, M, 2, 6, 0 } };// 建立一个权值矩阵
ArrayList<Integer[][]> list=flody(dist);
display_path(list);
}
}
感谢:http://www.cnblogs.com/twjcnblog/archive/2011/09/07/2170306.html
相关文章推荐
- 算法基础 - 多源点最短路径(Floyd算法)
- 6.3.3 最短路径算法--Dijkstra算法,Bellmanford算法,Floyd算法,Johnson算法
- 最短路径Dijkstar算法和Floyd算法详解(c语言版)
- Dijkstra算法和Floyd算法简介(最短路径算法)
- Dijkstra [迪杰斯特拉]算法思路(求单点到其他每个点的各个最短路径)Floyd算法:任意两点间最短距离
- 最短路径Dijkstar算法和Floyd算法详解(c语言版)
- 最短路径算法—Dijkstra算法与Floyd算法
- 数据结构与算法15:单源最短路径弗洛伊德Floyd算法
- 最短路径算法 Dijkstra算法 Floyd算法 简述
- 最短路径Dijkstar算法和Floyd算法详解(c语言版)
- 最短路径算法--Dijkstra算法,Bellmanford算法,Floyd算法,Johnson算法
- [链接]最短路径的几种算法[迪杰斯特拉算法][Floyd算法]
- 图论最短路径算法-Floyd算法-JAVA代码实现
- 最小生成树(Prime算法、Kruskal算法)和最短路径算法(Floyd算法、DijKstra算法)
- 「关于单源最短路径的三种算法的思考(不包括计算多点路径的Floyd算法)」
- 最短路径算法--DIJKSTRA算法,BELLMANFORD算法,FLOYD算法,JOHNSON算法
- 经典算法之Floyd算法(求图中任意一对顶点间的最短路径)
- 无权图单源最短路径算法和有权图单源最短路径算法(用到Dijkstra算法)和多源最短路径算法(用到Floyd算法)
- 最短路径算法之一——Floyd算法
- 所有顶点之间的最短路径算法:Floyd算法。