2021蓝桥JavaB:路径

【问题描述】

小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图 中的最短路径。

小蓝的图由 2021 个结点组成，依次编号 1 至 2021。

对于两个不同的结点 a, b，如果 a 和 b 的差的绝对值大于 21，则两个结点 之间没有边相连；如果 a 和 b 的差的绝对值小于等于 21，则两个点之间有一条 长度为 a 和 b 的最小公倍数的无向边相连。

例如：结点 1 和结点 23 之间没有边相连；结点 3 和结点 24 之间有一条无 向边，长度为 24；结点 15 和结点 25 之间有一条无向边，长度为 75。

请计算，结点 1 和结点 2021 之间的最短路径长度是多少。
—————————————————————————————————————————  

【解题过程】

首先我们思考怎么解决最小公倍数与最短路径的问题，然后我们来看几个与计算距离有关的算法。做题最重要的是掌握核心知识点，一通百通。分享两个视频和我觉得有助于我们理解的一些文章。

与蓝桥杯路径有关b站视频链接：第十二届蓝桥杯省赛试题精讲2-Java大学B组（Java、Python语言）_哔哩哔哩_bilibili

与路径有关的B站视频链接：

《大话数据结构》最短路径问题_哔哩哔哩_bilibili

弗洛伊德算法讲解清楚的文章（优快云）：http://t.csdn.cn/2ymX2

最短路径的四种算法（优快云）：http://t.csdn.cn/HWVgk

我就来做一个小小的总结。

最小公倍数，考虑欧几里得最大公约数。

最短路径，如字面意思一样要选择最短的，我们只需解决如何获取最短的算法就容易多了。最短路径的算法有弗洛伊德算法，迪杰斯特拉算法。

【弗洛伊德算法描述】

 【算法描述】

【解题代码_01】

package com.company;

public class Main {

    public static void main(String[] args) {
	// write your code here
        getDistance();
    }

    public static void getDistance() {
        long max=999999999;
        long points[][]=new long[2021][2021];
        for(int i=0;i<2021;i++){
            for (int j=0;j<2021;j++){
                if(i==j){
                    points[i][j]=0;
                }else if (Math.abs(i-j)>21){
                    points[i][j]=max;
                }else{
                    points[i][j]=getGB(i+1,j+1);
                }
            }
        }
        for(int k=0;k<2021;k++){
            for(int i=0;i<2021;i++){
                for(int j=0;j<2021;j++){
                    if(points[i][k]+points[k][j]<points[i][j]){
                        points[i][j]=points[i][k]+points[k][j];
                    }
                }
            }
        }
        System.out.println(points[0][2020]);
    }
    public static long getGB(long m,long n){
        long m1=m;
        long n1=n;
        //欧几里得最大公约数
        while(m%n!=0){
            long oldem=m;
            long olden=n;
            m=n;
            n=oldem%olden;
        }
        return m1*n1/n;
    }
}

---

【解题代码_02】

package com.company;
public class Main {

    static final int n = 2021;
    //求ab之间的最大公约数
    static int gcd(int a,int b){

        return b == 0 ? a : gcd(b,a%b);
    }
    //求ab之间的最小公倍数
    static int lcm(int a,int b){

        return a * b / gcd(a,b);
    }

    public static void main(String[] args) {
        //记录两点之间的边长，初始值都为零，如果数组某点未变化则说明两点之间没有边长
        int[][] floyd = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i+1; j < n && j < i+22 ; j++) {
                //根据题意可知两点之间的边长相等且等于最小公倍数，如果两点之间的差值大于21，两点间没有边长
                floyd[i][j] = floyd[j][i] = lcm(i+1,j+1);
            }
        }
        //弗洛伊德算法
        for (int k = 0; k < n; k++) {
            //中介点为k
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    //（i和k、k和j之间的边长不为零且（i和j之间没有边长或者通过中介点k，i到k，k到j的距离之和小于i到j的距离））成立则替换i到j的距离
                    if(floyd[i][k] != 0 && floyd[k][j] != 0 && (floyd[i][j] == 0 || floyd[i][k] + floyd[k][j] < floyd[i][j]))
                        floyd[i][j] = floyd[i][k] + floyd[k][j];
//                      这里是弗洛伊德算法的核心部分
//                     k为中间点
//                    for(k = 0; k < G.vexnum; k++){
//                        //v为起点
//                        for(v = 0 ; v < G.vexnum; v++){
//                            //w为终点
//                            for(w =0; w < G.vexnum; w++){
//                                if(D[v][w] > (D[v][k] + D[k][w])){
//                                    D[v][w] = D[v][k] + D[k][w];//更新最小路径
//                                    P[v][w] = P[v][k];//更新最小路径中间顶点
//                                }
//                            }
//                        }
//                    }
                    
                }
            }
        }
        //经过循环后，找出数组存储1到点2021之间的数据，该数据则为最短距离。
        System.out.println(floyd[0][n-1]);
    }
}

备注：这是一位码友的代码，我只是在原有的基础上添加了一些助于我理解的东西。大家一定要自己敲一遍才会慢慢有成效，原文连接看这里ヾ(◍°∇°◍)ﾉﾞhttp://t.csdn.cn/qkXmr

友情小提示：想要考研的友友们，数据结构特别重要哦，一定要熟悉各种算法。代码不会敲就模仿，照着穷敲，模仿的多了，加上边模仿边思考，慢慢的你也可以敲自己的代码了，慢慢的你也就会了。