经典算法 - 最短路径问题与Dijkstra、Floyd算法

最新推荐文章于 2023-05-21 14:17:31 发布
最新推荐文章于 2023-05-21 14:17:31 发布
阅读量351 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/key_768/article/details/108333754
版权

图的最短路径问题

前面介绍了图的基本知识：数据结构 - 图与深度优先、广度优先遍历

现有一个图：有7个顶点{'A','B','C','D','E','F','G'}，顶点间长度为权值

在这里插入图片描述

假设起点为G，现要求G点到各顶点的最短路径

迪杰斯特拉算法（Dijkstra）

Dijkstra算法以起始点为中心向外层层扩展（广度优先遍历），采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止

百度百科：
在这里插入图片描述

核心思路：

  • 设置3个数组：alreadyArr记录以访问的顶点；preVisited记录各个顶点前驱结点；dis记录起点到各顶点的距离
  • 从起点1开始广度优先遍历（每次遍历都更新3个数组，如顶点3的前驱结点为1，距离为9…后续遍历如果有更小值会覆盖）；找到权值最小的边<1,2>=7，即下一个访问的顶点2，设置顶点2的前驱结点为1，距离为7
  • 从顶点2开始广度遍历，重复上一步，到顶点3的距离为7+10=17>9，不更新preVisited和dis，选中顶点3，直到所有顶点都被访问，dis数组就是最终结果

Java代码实现Dijkstra算法

  • 算法创建了3个对象：Graph图对象、VisitedVertex已访问顶点的集合，保存了3个数组；DijkstraAlgorithm主类
  • VisitedVertex对象：初始化时需要设置dis自身为0，其余全为最大值（表示不连通），且设置起点被访问；updateArr方法为根据边权值选择下一访问点，访问alreadyArr集合与之对应的dis集合数据，找到最小值
  • Graph图：update方法更新index下标顶点到周围顶点的距离dis数组和周围顶点的前驱顶点preVisited数组；dijkstra方法，从起点开始调用update方法直到所有顶点被访问
package com.company.十种算法.dijkstra;

import java.util.Arrays;

/**
 * Author : zfk
 * Data : 17:15
 */
public class DijkstraAlgorithm {

    //用INF表示两个顶点不能连通
    private static final int INF = 65535;

    public static void main(String[] args) {


        char[] vertex = new char[]{'A','B','C','D','E','F','G'};
        int[][] matrix = {
                {INF,5,7,INF,INF,INF,2},
                {5,INF,INF,9,INF,INF,3},
                {7,INF,INF,INF,8,INF,INF},
                {INF,9,INF,INF,INF,4,INF},
                {INF,INF,8,INF,INF,5,4},
                {INF,INF,INF,4,5,INF,6},
                {2,3,INF,INF,4,6,INF}

        };
        Graph graph = new Graph(vertex, matrix);

        graph.showGraph();


        graph.dijkstra(6);
        graph.showDij();
    }

}


class Graph{
    //顶点数组
    private char[] vertex;
    //邻接矩阵
    private int[][] matrix;
    //表示已经访问的顶点的集合
    private VisitedVertex visitedVertex;

    public Graph(char[] vertex, int[][] matrix) {
        this.vertex = vertex;
        this.matrix = matrix;
    }
    public void showDij(){
        visitedVertex.show();
    }

    public void showGraph(){
        for (int[] link : matrix){
            System.out.println(Arrays.toString(link));
        }
    }
    /**
     * dijkstra算法实现
     * @param index 出发顶点对应的下标
     */
    public void dijkstra(int index){
        visitedVertex = new VisitedVertex(vertex.length, index);
        //更新index顶点到周围顶点的距离和前驱
        update(index);

        for (int j = 1;j < vertex.length;j++){
            //选择并返回新的访问结点
            index = visitedVertex.updateArr();
            //更新index顶点到周围顶点的距离和前驱
            update(index);
        }
    }

    //更新index下标顶点到周围顶点的距离和周围顶点的前驱顶点
    private void update(int index){
        int len = 0;
        //根据遍历我们的邻接矩阵matrix
        for (int j = 0;j < matrix[index].length;j++){
            //len 表示出发顶点到index顶点距离+从index顶点到j顶点的距离和
            len = visitedVertex.getDis(index) + matrix[index][j];
            //如果j顶点没有被访问过并且len 小于出发顶点到j顶点的距离，就需要更新
            if (!visitedVertex.in(j) && len < visitedVertex.getDis(j)){
                //更新顶点j的前驱为index
                visitedVertex.updatePre(j,index);
                //更新出发顶点到j顶点的距离
                visitedVertex.updateDis(j,len);
            }
        }
    }

}

//已访问顶点的集合
class VisitedVertex{
    //记录以访问的顶点 - 动态更新
    public int[] alreadyArr;
    //记录前驱结点，每个值为前一个顶点下标 - 动态更新
    public int[] preVisited;
    //记录出发顶点到其他所有顶点的距离,求的最短距离就会存在dis
    public int[] dis;

    /**
     *
     * @param length 顶点的格式
     * @param index 出发顶点对应的下标
     */
    public VisitedVertex(int length,int index) {
        this.alreadyArr = new int[length];
        this.preVisited = new int[length];
        this.dis = new int[length];
        //全部置为最大值
        Arrays.fill(dis,65535);
        //设置出发顶点被访问过
        this.alreadyArr[index] = 1;
        //自身置0
        this.dis[index] = 0;
    }

    /**
     * 判断index顶点是否被访问过
     * @param index
     * @return 访问过返回true，否则为false
     */
    public boolean in(int index){
        return alreadyArr[index] == 1;
    }

    /**
     * 更新出发顶点到index顶点的距离
     * @param index
     * @param len
     */
    public void updateDis(int index,int len){
        dis[index] = len;
    }

    /**
     * 更新顶点的前驱结点为index
     * @param pre
     * @param index
     */
    public void updatePre(int pre,int index){
        preVisited[pre] = index;
    }

    /**
     * 返回出发顶点到index顶点的距离
     * @param index
     */
    public int getDis(int index){
        return dis[index];
    }


    /**
     * 继续选择并返回新的访问顶点，G点访问完后，以A点作为新的访问顶点
     * @return
     */
    public int updateArr(){
        int min = 65535, index = 0;
        for (int i = 0;i < alreadyArr.length;i++){
            if (alreadyArr[i] == 0 && dis[i] < min){
                min = dis[i];
                index = i;
            }
        }
        //更新index顶点被访问过
        alreadyArr[index] = 1;
        return index;

    }

    /**
     * 显示最后的结果，即将三个数组的情况输出
     */
    public void  show(){

        System.out.println("==============已访问的顶点===============");
        //输出alreadyArr
        for (int i : alreadyArr){
            System.out.print(i+ " ");
        }
        System.out.println();
        System.out.println("===============前驱顶点==============");
        //输出preVisited
        for (int i : preVisited){
            System.out.print(i+ " ");
        }
        System.out.println();
        System.out.println("==============顶点间最短距离===============");
        //输出dis
        for (int i : dis){
            System.out.print(i+ " ");
        }
        System.out.println();
        char[] vertex = new char[]{'A','B','C','D','E','F','G'};
        int count = 0;
        for (int i : dis){
            if (i != 65535){
                System.out.print(vertex[count] + "( " + i + " )");
            }else {
                System.out.println(" N " );
            }
            count++;
        }

    }
}

最终结果：

在这里插入图片描述

弗洛伊德算法（Floyd）

同为最短路径问题的算法，floyd算法是得到所有顶点到其他顶点的最短路径（当然Dijkstra也可以）

floyd算法的核心思想是三层for循环与
状态转移方程dis[i][j] = min{dis[i][k] + dis[k][j]，dis[i][j]}即找到权值最小边

在这里插入图片描述

设置好两个二维数组：dis保存各顶点出发到其他顶点的距离；pre保存顶点的前驱结点
初始化时dis数组就是图的邻接矩阵，设置结点的前驱结点为自身
INF表示结点间不连通，顶点到自身的距离为0

        int[][] matrix = {
                {0,5,7,INF,INF,INF,2},
                {5,0,INF,9,INF,INF,3},
                {7,INF,0,INF,8,INF,INF},
                {INF,9,INF,0,INF,4,INF},
                {INF,INF,8,INF,0,5,4},
                {INF,INF,INF,4,5,0,6},
                {2,3,INF,INF,4,6,0}
        };

查找最短路径一般都是直连与间接连通的长度比较：min{dis[i][k] + dis[k][j]，dis[i][j]}，如AB的最短距离是<A,B>还是<A,G>+<G,B>呢？

所有我们引入中间结点，例如，以A为中间结点，所有经过A点的两顶点间的最短路径就是min{dis[i][0] + dis[0][j]，dis[i][j]}

  1. 起点为A，终点为{'A','B','C','D','E','F','G'}

与A连通的结点B、C、G，更新dis数组和pre数组；
不连通的设置一个最大值INF表示即可

  1. 起点为B，终点为{'A','B','C','D','E','F','G'}]
    实际上都大于以A为起点的距离，所以不用更新dis数组和pre数组

在这里插入图片描述

  1. 继续循环起点为{C,D,E,F,G}，找到所有经过顶点A的两顶点的最短路径

  2. 然后就是循环中间结点{'A','B','C','D','E','F','G'}，类似与穷举法，找出了所有可能，最终dis就是所有顶点到其他顶点的最短距离

Java代码实现floyd算法

floyd算法重点就在与三个for循环

package com.company.十种算法.floyd;

import java.util.Arrays;

/**
 * Author : zfk
 * Data : 16:51
 * 弗洛伊德算法 ： 最短路径问题(所有结点)
 */
public class FloydAlgorithm {

    //用INF表示两个顶点不能连通
    private static final int INF = 65535;

    public static void main(String[] args) {
        char[] vertex = new char[]{'A','B','C','D','E','F','G'};
        int[][] matrix = {
                {0,5,7,INF,INF,INF,2},
                {5,0,INF,9,INF,INF,3},
                {7,INF,0,INF,8,INF,INF},
                {INF,9,INF,0,INF,4,INF},
                {INF,INF,8,INF,0,5,4},
                {INF,INF,INF,4,5,0,6},
                {2,3,INF,INF,4,6,0}
        };

        Graph graph = new Graph(matrix, vertex);
        graph.floyd();
        graph.show();

    }
}

//图对象
class Graph{
    //图中顶点数组
    private char[] vertex;
    //保存各顶点出发到其他顶点的距离,最后结果也是保存在该数组
    private int[][] dis;
    //保存到达目标顶点的前驱结点
    private int[][] pre;

    /**
     * 构造器
     * @param matrix 邻接矩阵
     * @param vertex 顶点数组
     */
    public Graph(int[][] matrix,char[] vertex){
        int length = vertex.length;
        this.vertex = vertex;
        this.dis = matrix;
        this.pre = new int[length][length];
        //对pre初始化，最开始时各顶点的前驱为自身
        // 且该数组存放的是顶点的下标 'A' - 0
        for (int i =0;i < length;i++){
            Arrays.fill(pre[i],i);
        }

    }

    //显示pre数组合dis数组
    public void show(){
        System.out.println("==========pre数组============");
        for (int k = 0;k < dis.length;k++){
            for (int j = 0;j < dis.length;j++){
                System.out.print(vertex[pre[k][j]] + " ");
            }
            System.out.println();
        }

        System.out.println("==========dis数组============");
        for (int k = 0;k < dis.length;k++){
            for (int j = 0;j < dis.length;j++){
                System.out.printf("%2d\t",dis[k][j]);
            }
            System.out.println();
        }

    }

    //弗洛伊德算法
    public void floyd(){
        //两顶点的距离
        int len = 0;
        int length = dis.length;

        //对中间顶点数组变量，k为中间顶点数组的下标,{'A','B','C','D','E','F','G'}
        for (int k = 0;k < length;k++){
            //从i顶点出发,{'A','B','C','D','E','F','G'}
            for (int i = 0;i < length;i++){
                //j顶点为终点,{'A','B','C','D','E','F','G'}
                for (int j = 0;j < length;j++){
                    //从i顶点出发经过k中间顶点，到达j顶点的距离
                    len = dis[i][k] + dis[k][j];
                    //len小于两顶点直连的距离，就更新
                    if (len < dis[i][j]){
                        dis[i][j] = len;
                        //设置前驱结点
                        pre[i][j] = pre[k][j];
                    }
                }

            }

        }
    }

}
有机后浪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python Dijkstra算法实现最短路径问题的方法
09-18
主要介绍了python Dijkstra算法实现最短路径问题的方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Floyd算法求解各顶点之间最短路径问题
weixin_51780040的博客
03-07 4804
Floyd算法基于动态规划思想，通过一个二维数组记录从一个节点到另一个节点的最短路径长度。算法的核心思想是逐渐增加中间节点，如果在加入一个中间节点后能够获得更短的路径，则更新路径长度。Floyd算法，也称为Floyd-Warshall算法，是一种用于求解图中所有节点之间最短路径的算法。如图：这是一个有三个顶点的有向图，矩阵A存储了两点之间的最短距离，在初始状态下就是一个邻接矩阵；矩阵pre记录了两点之间的最短路径中，加入的中转顶点。的最短路径长度是10，从pre可以知道，从。这个路径路径中，加入了。
图解最短路径之弗洛伊德算法（Java实现）
热门推荐
编码强迫症患者
05-28 2万+
概述 Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法是一种在具有正或负边缘权重（但没有负环）的加权图中找到最短路径的算法，即支持负权值但不支持负权环。弗洛伊德算法采用的是动态规划思想，其状态转移方程如下： 其中matrix[i,j]表示i到j的最短距离，k是穷举i到j之间可能经过的中间点，当中间点为k时，......
最短路径问题—Dijkstra算法和Floyd算法
24考研人晴落的博客
10-28 2341
最短路径问题一般分为两类：一是单源最短路径，即求图中某一顶点到其他顶点的最短路径，可通过Dijkstra(迪杰斯特拉)算法求解；二是求每一对顶点间的最短路径，可通过Floyd( 弗洛伊德)算法求解。
图算法——求最短路径（Floyd算法）
在夜里行走的博客
03-18 6228
在网图和非网图中，最短路径的含义是不同的。由于非网图没有边上的权值，所谓最短路径，其实指的就是两个顶点之间经过的边数最少的路劲（即可以理解为把每一条边的权值看作是1）。对于网图来说，所谓最短路径，就是指两顶点之间经过的边上的权值之和最少的路径，并且我们称路径上的第一个顶点是源点，最后一个顶点是终点。求带权有向图G的最短路径问题一般可分为两类：一是单源最短路径，即求图中某一个顶点到其它顶点的最短路径，可以通过经典的 Dijkstra（迪杰斯特拉）算法求解（这是我写的一篇博客，有兴趣的同学可以看下，
最短路径——Floyd算法
m0_51339444的博客
04-01 1万+
最短路径——Floyd算法
数据结构之——最短路径（Dijkstra算法和Floyd算法）
xiaoyong5854的博客
06-04 3345
最短路径是图论中一个很经典的问题：给定图G(V,E),求一条从起点到终点的路径，使的这条路径上经过的所有边的边权之和最小。 1.Dijkstra算法 Dijkstra算法（迪杰斯特拉）用来解决单源最短路径问题，即给定图G和起点s，通过算法得到s到达其他顶点的最短距离。Dijkstra的基本思想是对图G(V,E)设置集合S，存放已被访问的顶点，然后每次从集合V-S中选择与起点s的最短距离最小的一个顶点(记为u)，访问并加入集合S，之后，令顶点u为中介点，优化起点s与所有从u能到达的顶点v之间的最短距离，这样的
数据结构——Floyd算法（寻找最短路径）
邓占勇的博客
12-30 5087
Floyd算法 Floyd算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。 在计算机科学中，Floyd-Warshall算法是一种在具有正或负边缘权重（但没有负周期）的加权图中找到最短路径的算法。算法的单个执行将找到所有顶点对之间的最短路径的长度（加权）。 虽然它不返回路径本身的细节，但是可以通过对算法的简单修改来重建路径。 ...
利用Floyd算法求解最短路径问题
m0_69878069的博客
05-21 715
利用Floyd算法求解最短路径问题
七、最短路径——弗洛伊德（Floyd）算法
ThinPikachu的博客
03-23 2万+
为了能讲明白弗洛伊德（Floyd）算法的精妙所在，我们先来看最简单的案例。下图是一个最简单的3个顶点连通网图。 我们先定义两个二维数组D[3][3]和P[3][3]，D代表顶点到顶点的最短路径权值和的矩阵。P代表对应顶点的最小路径的前驱矩阵。在未分析任何顶点之前，我们将D命名为，其实它就是初始的图的邻接矩阵。将P命名为，初始化为图中所示的矩阵。 首先我们来分析，所有的顶点经过v0后到达另一顶点的最短路径。因为只有...
用贪心算法解单源最短路径问题
05-02
用贪心算法解单源最短路径问题 明确单源最短路径问题的概念；利用贪心算法解决单源最短路径问题；并通过本例熟悉贪心算法在程序设计中的应用方法。
C/C++手撕代码 算法实现 最短路径 Dijkstra算法与Floyd算法
最新发布
12-26
C/C++手撕代码 最短路径 Dijkstra算法与Floyd算法-C/C++手撕代码算法实现 最短路径算法实现 Dijkstra算法实现 Floyd算法实现
Python使用Dijkstra算法实现求解图中最短路径距离问题详解
12-24
这里继续前面一篇《Python基于Floyd算法求解最短路径距离问题》的内容，这里要做的是Dijkstra算法，与Floyd算法类似，二者的用途均为求解最短路径距离，在图中有着广泛的应用，二者的原理都是老生常谈了，毕竟本科...
Dijkstra和Floyd算法找最短路径matlab实现
05-26
Dijkstra和Floyd算法找最短路径matlab实现，通信网作业
Python基于Floyd算法求解最短路径距离问题实例详解
12-23
Floyd算法和Dijkstra算法，相信大家都不陌生，在最短路径距离的求解中应该算得上是最为基础和经典的两个算法了，今天就用一点时间来重新实现一下，因为本科的时候学习数据结构才开始接触的这个算法，当时唯一会用的...
经典算法 - 动态规划算法及背包问题（01背包与完全背包）
key_768的博客
08-27 3219
动态规划 动态规划算法通常用于求解具有某种最优解的问题 基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 与分治法不同的是，动态规划分解得到的子问题往往不是互相独立的，即上一个子问题解可能为下一个子问题的条件（通常可以将结果填入表格） 背包问题 有一个背包容量为4kg，现在有以下物品 物体 重量 价格 吉他 1 1500 音响 4 3000 电脑 3 2000 现要求装入背包的物体价值最大，且不能超重 其中： 01背包问题：物品有
经典算法 - 贪心算法及集合覆盖问题
key_768的博客
08-29 2948
贪心算法 贪心算法：在对问题求解时，总是做出在当前看来是最好的选择 是由局部到整体，算法得到的是在某种意义上的局部最优解，对整体是近似最优解 贪心算法一般按如下步骤进行： 建立数学模型来描述问题 把求解的问题分成若干个子问题 对每个子问题求解，得到子问题的局部最优解 把子问题的解局部最优解合成原来解问题的一个解（近似于最优解，也可能是最优解） 贪心算法特点是一步一步地进行，以当前情况为基础根据作当前的最优选择，通过每一步贪心选择，可得到问题的一个最优解 集合覆盖问题 一个广播覆盖问题： 存在以下广播，
经典算法 - 回溯法解决骑士周游问题及贪心算法优化
key_768的博客
09-02 2261
骑士周游问题（马踏棋盘） 这是一个很经典的游戏，4399小游戏：马踏棋盘 马只能走日字，棋盘每个格子只能走一次，现在要求马跳遍整个棋盘，最终回到最初的位置 如果靠人来想挺难的，但是我们有计算机 通常采用回溯法或启发式搜索类算法求解 回溯法 分析： 棋盘可以看做一个二维数组chessboard，可以用Point对象代表一个位置 一个马最多可以走8个方向，分别标号（这里标号的顺序不同会造成结果不同，都是问题的解） 即可以写一个方法判断当前位置curPoint的下一步哪些位置可走（8个for循环） 创
数据结构 - 解析二叉树的顺序存储
key_768的博客
06-21 1631
顺序存储结构 二叉树的存储结构可以分为两种： 顺序存储：使用线性表（数组）存储二叉树 链式存储：使用链表存储二叉树 在上篇文章：数据结构 - 树、二叉树及四种遍历解析实现 使用链式存储二叉树，这篇完成顺序存储 顺序存储的特点 以数组的方式存放二叉树，要完成4种遍历方式，需要数组与树结点存在对应关系 顺序存储二叉树的特点 顺序二叉树通常只考虑完全二叉树 第n个元素的左子结点为 2 * n + 1 第n个元素的右子结点为 2 * n + 2 第n个元素的父结点为 (n - 1) / 2 n表示数
详解最短路径中Dijkstra算法和Floyd算法
05-20
Dijkstra算法和Floyd算法都是用于解决最短路径问题的算法，但它们的实现方式略有不同。 Dijkstra算法：以单个顶点为起点，依次计算出到其他各个顶点的最短距离。 算法步骤： 1. 初始化集合S={起点}和不在集合S中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值