十大常用算法之佛洛依德算法

最新推荐文章于 2024-08-17 21:09:44 发布

同学郑学习

最新推荐文章于 2024-08-17 21:09:44 发布

阅读量1.3k

点赞数

分类专栏： # 算法笔记文章标签：算法

本文链接：https://blog.csdn.net/weixin_46635575/article/details/121714678

版权

算法笔记专栏收录该内容

35 篇文章 0 订阅

订阅专栏

十大常用算法的完整实现

一、基本介绍

1、基本介绍

在这里插入图片描述

2、图解Floyd算法【也是求最短路径的】

（1）先初始化两个需要的数组

在这里插入图片描述

（2）找过度节点

在这里插入图片描述

（3）总体思路

首先知道了什么是过度节点后。接下来看一下佛洛依德的算法思路
在这里插入图片描述

首先以第一个中间节点A为过度节点
- 然后就再以A为出发点，
  - 下面的A，BCDEFG为终点进行遍历
- 然后再以B为出发点，
  - 下面的A,BCDEFG为终点进遍历
- 然后再以C，D，E，F，G做为起点，循环遍历下去
然后再以第二个中间节点B为过度节点，循环的往下面找
然后就以CDEFG为过度节点进行遍历查找
但是佛洛依德算法挺好，但是时间复杂度很高的，有三层for循环进行处理

最后得到的一个结果当以A为过度节点时候就得到一个最短路径，再以B作为过度节点的时候又得到一个最短路径，最后得到了每一个村庄到某一个村庄的最短距离。

二、代码实现

（1）题目

在这里插入图片描述

总体的解决问题是先创建好图，并且处理好显示的效果
然后再进行我们佛洛依德的结果计算

（2）图的创建

import java.util.Arrays;

public class floydDome {
    public static void main(String[] args) {
        //先测试图是否创建成功
        char[] vertx = {'A','B','C','D','E','F','G'};
        //创建领接矩阵
        int[][] matrix = new int[vertx.length][vertx.length];
        final int N = 65535;
        matrix[0] =new int[]{0,5,7,N,N,N,2};
        matrix[1] =new int[]{5,0,N,9,N,N,3};
        matrix[2] =new int[]{7,N,0,N,8,N,N};
        matrix[3] =new int[]{N,9,N,0,N,4,2};
        matrix[4] =new int[]{N,N,8,N,0,5,4};
        matrix[5] =new int[]{N,N,N,4,5,0,6};
        matrix[6] =new int[]{2,3,N,N,4,6,0};
        //创建图对象来使用
        MGraph mGraph = new MGraph(vertx.length,matrix,vertx);
        mGraph.show();
    }
}


class MGraph {
    private char[] vertexs;//存放顶点的一个数组
    private int [][] dis;//用于记录各个村庄到某个村庄的距离，最后结果也是在这里面
    private int[][] pre;//保存到达目标村庄的前驱村庄,这个是动态生成的

    //构造器

    /**
     *
     * @param length 大小
     * @param matrix 领接矩阵
     * @param vertexs 顶点数组
     */
    public MGraph(int length, int[][] matrix,char[] vertexs) {
        this.vertexs = vertexs;
        this.dis = matrix;
        this.pre = new int[length][length];
        //初始化我们的pre的前驱节点，存放的是前驱节点的下标，并不是存放的A或B什么的
        for (int i = 0; i < length; i++) {
            Arrays.fill(pre[i],i);
        }
    }

    //显示dis和pre的方法
    public void show() {
        for (int i = 0; i < dis.length; i++) {
            //显示pre数组
            for (int j = 0; j < dis.length; j++) {
                System.out.print(vertexs[pre[i][j]] + " ");
            }
            System.out.println();
            //输出dis数组
            for (int j = 0; j < dis.length; j++) {
                System.out.print("{" +vertexs[i] + "到" + vertexs[j] + "的最短路径" + dis[i][j] + "}");
            }
            System.out.println();
        }
    }
}

（3）佛洛依德算法

在我们的图类里面添加如下方法

//佛洛依德算法的实现
    public void floyd() {
        int len = 0;//变量用于记录距离

        //对中间顶点的遍历，k就是中间顶点的下标也就是从A到G
        for (int k = 0; k < dis.length; k++) {
            //表示从i顶点开始出发，也就是从A到G
            for (int i = 0; i < dis.length; i++) {
                //表示从i顶点出发，要到的j节点
                for (int j = 0; j < dis.length; j++) {
                    len = dis[i][k] + dis[k][j];//相当于求出了从i出发经过k中间顶点，到j节点的距离
                    if (len < dis[i][j]) {
                        //入过小于从i到k到j的距离小于直接从i到k的直连距离，那就更新
                        dis[i][j] = len;//就更新一波
                        //然后再更新一下前驱节点
                        pre[i][j] = pre[k][j];//更新前驱节点
                    }
                }
            }
        }
    }