数据结构 最短路径问题 Floyd算法
来源:互联网 发布:双序列比对算法 编辑:程序博客网 时间:2024/05/26 02:51
数据结构 最短路径问题 Floyd算法
最短路径问题
是图论研究中的一个经典算法问题,旨在寻找图(由结点和边(路径)组成的)中两结点之间的最短路径。算法具体的形式包括:
1、确定起点的最短路径问题:
— 即已知起始结点,求最短路径的问题。适合Dijkstra算法。
2、确定终点的最短路径问题:
— 与确定起点的问题相反,该问题是已知终结结点,求最短路径的问题。
在无向图中该问题与确定起点的问题完全等同,
在有向图中该问题等同于把所有路径方向反转的确定起点的问题。
3、确定起点和终点的最短路径问题:
— 即已知起点和终点,求两结点之间的最短路径。
4、全局最短路径问题:
— 求图中所有的最短路径。适合Floyd算法。
最短路径问题算法:
迪杰斯特拉算法(Dijkstra算法)
弗洛伊德算法(Floyd算法)
SPFA算法
弗洛伊德算法(Floyd算法)
一种用于寻找给定的加权图中顶点间最短路径的算法,是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权的最短路径问题,同时也被用于计算有向图的传递闭包。
Floyd算法的时间复杂度为O(N^3),空间复杂度为O(N^2)。
Floyd算法基本思想:
Floyd算法是一个经典的动态规划算法。
首先我们的目标是寻找从点i到点j的最短路径:从任意节点i到任意节点j的最短路径不外乎2种可能:
1、直接从i到j
2、从i经过若干个节点k到j
假设Dis(i,j)为节点u到节点v的最短路径的距离,对于每一个节点k,我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立,如果成立,证明从i到k再到j的路径比i直接到j的路径短,
则设置Dis(i,j) = Dis(i,k) + Dis(k,j),遍历完所有节点k,则Dis(i,j)中记录的便是i到j的最短路径的距离。
int n = 7;
int a[n][n] = { //初始化S – 将图的邻接矩阵a复制到S中
/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}};
经过更新后的各顶点间最短路径矩阵S:
0 12 22 22 18 16 14
12 0 10 13 9 7 16
22 10 0 3 5 6 13
22 13 3 0 4 6 12
18 9 5 4 0 2 8
16 7 6 6 2 0 9
14 16 13 12 8 9 0
初始状态:S是记录各个顶点间最短路径的矩阵。
第1步:初始化S。
矩阵S中顶点a[i][j]的距离为顶点i到顶点j的权值;如果i和j不相邻,则a[i][j]=∞。实际上,就是将图的邻接矩阵a复制到S中。
a[i][j]:表示矩阵S中顶点i(第i个顶点)到顶点j(第j个顶点)的距离。
第2步:
对于每一对顶点u和v,看看是否存在一个顶点w使得从u到w再到v比己知的路径更短:
以顶点A(第1个顶点)为中介点,若a[i][j] > a[i][0]+a[0][j],则设置a[i][j]=a[i][0]+a[0][j]。
以顶点a[1][6],从s中发现a[1][6]=∞;将A作为中介点时,a[1][0] = (B,A)=12,a[0][6] = (A,G)=14,因此B和G之间的距离可以更新为26, 即s[1][6]=26,s[6][1]=26。
以顶点a[0][2],从s中发现a[0][2]=∞;将B作为中介点时,a[0][1] = (A,B)=12,a[1][2] = (A,B)=10,因此A和C之间的距离可以更新为22, 即s[0][2]=22,s[2][0]=22。
第3步:
同理,依次将顶点B,C,D,E,F,G作为中介点,并更新a[i][j]的大小。
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 = 100;//Integer.MAX_VALUE; // 最大值 public MatrixUDG(char[] vexs, int[][] matrix) { int vlen = vexs.length; // 初始化"顶点数"和"边数" mVexs = new char[vlen]; // 初始化"顶点" for (int i = 0; i < mVexs.length; i++) mVexs[i] = vexs[i]; mMatrix = new int[vlen][vlen]; // 邻接矩阵: 初始化"边" mMatrix[i][j]=1,则表示"顶点i(即mVexs[i])"和"顶点j(即mVexs[j])"是邻接点;mMatrix[i][j]=0,则表示它们不是邻接点 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++; } //返回顶点v的第一个邻接顶点的索引,失败则返回-1 private int firstVertex(int v) { if (v<0 || v>(mVexs.length-1)) return -1; for (int i = 0; i < mVexs.length; i++) if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF) return i; return -1; } // 返回顶点v相对于w的下一个邻接顶点的索引,失败则返回-1 private int nextVertex(int v, int w) { if (v<0 || v>(mVexs.length-1) || w<0 || w>(mVexs.length-1)) return -1; for (int i = w + 1; i < mVexs.length; i++) if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF) return i; return -1; } // 返回顶点v相对于w的下一个邻接顶点的索引,失败则返回-1 private int nextVertexs(int v) { if (v<0 || v>(mVexs.length-1)) return -1; for (int i=0; i < mVexs.length; i++) { if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF) { System.out.print("邻接点"+mVexs[i]+"权重("+mMatrix[v][i]+")"); } } return -1; } //获取图中的边 private void getEdges() { int index=0; System.out.print("edges = "+mEdgNum); System.out.println(); for (int i=0; i < mVexs.length; i++) { for (int j=0; j < mVexs.length; j++) { if (mMatrix[i][j]!=INF && mMatrix[i][j] != 0) { System.out.println("结点"+mVexs[i]+"和结点"+mVexs[j]+"的边,权重"+mMatrix[i][j]); } } } System.out.println(); } /* * floyd最短路径。 * 即,统计图中各个顶点间的最短路径。 * path -- 路径。path[i][j]=k表示,"顶点i"到"顶点j"的最短路径会经过顶点k。 * dist -- 长度数组。即,dist[i][j]=sum表示,"顶点i"到"顶点j"的最短路径的长度是sum。 */ public void floyd(int[][] path, int[][] dist) { // 初始化 for (int i = 0; i < mVexs.length; i++) { for (int j = 0; j < mVexs.length; j++) { dist[i][j] = mMatrix[i][j]; // "顶点i"到"顶点j"的路径长度为"i到j的权值"。 path[i][j] = j; // "顶点i"到"顶点j"的最短路径是经过顶点j。 } } // 计算最短路径 for (int k = 0; k < mVexs.length; k++) { for (int i = 0; i < mVexs.length; i++) { for (int j = 0; j < mVexs.length; 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("最短路径矩阵: \n"); for (int i = 0; i < mVexs.length; i++) { for (int j = 0; j < mVexs.length; j++) System.out.printf("%2d ", dist[i][j]); System.out.printf("\n"); } System.out.println(); System.out.printf("最短路径经过的顶点矩阵: \n"); for (int i = 0; i < mVexs.length; i++) { for (int j = 0; j < mVexs.length; j++) System.out.printf("%2d ", path[i][j]); System.out.printf("\n"); } } 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, INF, 2, 0, 9}, /*G*/ { 14, INF, INF, INF, 8, 9, 0}}; int length = vexs.length; int i=0, j; System.out.print("结点表: \n"); for(char label:vexs) { System.out.print("结点"+i+", 标识"+label+"\n"); i++; } System.out.print("\n"); System.out.print("邻接矩阵: \n"); for(i=0; i<length; i++){ for(j=0; j<length; j++) { System.out.printf("%2d ", matrix[i][j]); } System.out.print("\n"); } System.out.print("\n"); MatrixUDG pG; pG = new MatrixUDG(vexs, matrix); //pG.getEdges(); for(i=0; i<length; i++){ //System.out.printf("顶点%d邻接点%d\n", i, pG.firstVertex(i)); System.out.print("顶点"+vexs[i]); pG.nextVertexs(i); System.out.print("\n"); } System.out.print("\n"); 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); }}
- 数据结构 最短路径问题 Floyd算法
- Floyd算法解决最短路径问题
- 最短路径问题---Floyd算法详解
- 最短路径问题(Floyd算法)
- 最短路径问题(Floyd算法)
- 最短路径问题(floyd算法)
- 最短路径问题---Floyd算法详解
- 数据结构-最短路径—Dijkstra算法和Floyd算法
- Floyd最短路径算法
- 最短路径(Floyd算法)
- 最短路径 floyd算法
- 最短路径--Floyd算法
- Floyd最短路径算法
- Floyd最短路径算法
- 最短路径Floyd算法
- 最短路径 Floyd算法
- Floyd最短路径算法
- 最短路径floyd算法
- Linux下yum安装java
- spring(七)ssh2框架搭建
- 实时重复文章识别——SimHash
- C++纯虚函数和Java中的抽象函数区别
- Maven学习03--使用Eclipse maven创建普通java项目
- 数据结构 最短路径问题 Floyd算法
- Java中的伪共享以及应对方案
- acm2899 Strange fuction
- 剑指offer——复杂链表的复制_
- HTC Vive开发笔记之手柄震动
- AC自动机【萌新文章】
- UE4之玩家攻击AI(4)
- A Trip To Deep Learning
- c++设计模式之备忘录模式