一道水群中问题的解答(最短路径问题)

在QQ水群中传来这样一个问题


这是一道最短路径的问题，我打算采用弗洛伊德算法，寻找起始点到每一个点的最短路径及对应的最小过路费。

package com.stack.dfs;


import java.util.Arrays;
import java.util.Scanner;

public class Path {

    public static void main(String[] args) {
        int N, M, S, D;
        Scanner scanner = new Scanner(System.in);
        N = scanner.nextInt();
        M = scanner.nextInt();
        S = scanner.nextInt();
        D = scanner.nextInt();

        int[][] matrix = new int[M][4];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                matrix[i][j] = scanner.nextInt();
            }
        }
        scanner.close();

        int[][] path = new int[N][N];
        int[][] weight = new int[N][N];
        for (int[] w : weight) {
            Arrays.fill(w, -1);
        }
        for (int[] p : path) {
            Arrays.fill(p, -1);
        }
        for (int[] row : matrix) {
            path[row[0]][row[1]] = row[2];
            path[row[1]][row[0]] = row[2];
            weight[row[0]][row[1]] = row[3];
            weight[row[1]][row[0]] = row[3];
        }
        for (int i = 0; i < path.length; i++) {
            path[i][i] = 0;
            weight[i][i] = 0;
        }
        findMinPath(path, weight, S);
    }

    public static void findMinPath(int[][] matrix, int[][] weight, int start) {
        if (matrix.length != weight.length || !isSymmetric(matrix) || !isSymmetric(weight))
            throw new NegativeArraySizeException("the size of weight and matrix is not consistent");
        // 0点到各个点的最短路径
        int[] minPath = new int[matrix.length];
        // 最短路径对应的过路费
        int[] money = new int[matrix.length];

        // 初始化,将最短路径值和权值初始化为以起点为开始的值
        System.arraycopy(matrix[start], 0, minPath, 0, matrix.length);
        System.arraycopy(weight[start], 0, money, 0, weight.length);
        for (int i = 0; i < matrix.length; i++) {
            if (i != start) {
                for (int j = 0; j < matrix.length; j++) {
                    if (j != start) {
                        // 只有两者都是最短路径时才进一步比较权值的大小
                        if (matrix[i][j] != -1 && (minPath[i] + matrix[i][j] == minPath[j])) {
                            if (money[j] > money[i] + weight[i][j] && weight[i][j] != -1 && money[i] != -1) {
                                money[j] = money[i] + weight[i][j];
                            }
                        }
                        // 如果存在最小的路径，那么直接赋权值
                        if (matrix[i][j] != -1 && (minPath[i] + matrix[i][j] < minPath[j]) && minPath[i] != -1) {
                            minPath[j] = minPath[i] + matrix[i][j];
                            if (weight[i][j] != -1 && money[i] != -1) {
                                money[j] = money[i] + weight[i][j];
                            }
                        }
                    }
                }
            }
        }
        // 打印出结果
        for (int i = 0; i < minPath.length; i++) {
            System.out.printf("%d到%d的最短路径为%d, 花费最少金额为%d ;\n", start, i, minPath[i], money[i]);
        }
    }

    // 判断矩阵是否是对称矩阵
    public static boolean isSymmetric(int[][] matrix) {
        if (matrix.length != matrix[0].length) return false;
        for (int i = 0; i < matrix.length; i++) {
            for (int j = i; j < matrix.length; j++) {
                if (matrix[i][j] != matrix[j][i])
                    return false;
            }
        }
        return true;
    }
}