最短路解法

算法介绍：

Floyd：任意两个点之间的最短路径或者是负权图，用Floyd，时间复杂度O（n^3）
Dijkstra：单源点正权图，时间复杂度为O（n^2）(使用了动规思想）

Floyd模型构建

目标：求出某一点到达任意一点的最短距离
用city[i][j]表示从i到j的距离，把自己到自己设为0，把自己到不了的点设置为一个非常大的数，注意题目要求两个点之间的路是单向还是双向的

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[][] city=new int[n][n];
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i==j){
                    city[i][j]=0;
                }else
                    city[i][j]=Integer.MAX_VALUE;
            }
        }
        //读取边数据
    }

算法部分

for(int m=0;m<city.length;m++){
            for(int i=0;i<city.length;i++){
                for(int j=0;j<city.length;j++){
                    if(city[i][m]+city[m][j]<city[i][j]){
                        city[i][j]=city[i][m]+city[m][j];
                    }
                }
            }
        }

此时的city[i][j]就得出i到j点的最短距离，后续根据题意再进行处理

Dijkstra算法
求单源点的最小距离

import java.util.*;

public class Main {
    //数据实例：共有500个点，每两点边长不超过10000
    //求顶点1到i的最短距离
    static int N = 510;
    static int n, m;
    //图
    static int[][] adjMatrix = new int[N][N];
    //判断点是否被遍历
    static boolean[] used = new boolean[N];
    //res[i]为顶点1到i的最短距离
    static int[] res = new int[N];

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        m=sc.nextInt();
        for (int i = 1; i <= n; i++) {
            
            Arrays.fill(adjMatrix[i], 10010);
        }
        int x,y,z;
        //给adjMatrix赋值
        for(int i=0;i<m;i++){
            x=sc.nextInt();
            y=sc.nextInt();
            z=sc.nextInt();
            //重边取最小值
            adjMatrix[x][y]=Math.min(adjMatrix[x][y],z);
        }
        
        getShortestPaths(adjMatrix);
        
        //res[i]即为结果集
        if(res[n]==10010)
            System.out.println("-1");
        else
            System.out.println(res[n]);
    }

    /*
     * 函数功能：返回顶点0到其它所有顶点的最短距离，其中顶点1到顶点1的最短距离为0
     */
    public static void getShortestPaths(int[][] adjMatrix) {
        Arrays.fill(res, 10010);
        res[1] = 0;//把自己的距离设为0

        //循环n次，在循环中逐个访问每个顶点，并不断修正权重
        for (int i = 0; i < n; i++) {
            int k = -1;//表示还没有最短的点
            for (int j = 1; j <= n; j++) {  //找到顶点0到其它顶点中距离最小的一个顶点
                if (!used[j] && (k == -1 || res[k] > res[j])) {
                    k = j;
                }
            }//循环后找到最短点k

            used[k] = true;    //将距离最小的顶点，记为已遍历
            //用k更新结果集
            for (int j = 1; j <= n; j++) {  //然后，将顶点0到其它顶点的距离与加入中间顶点k之后的距离进行比较，更新最短距离
                res[j] = Math.min(res[j], res[k] + adjMatrix[k][j]);
            }
        }
        
    }
}