Figura-algoritmo de Dijstra: resolución del camino más corto

La idea principal de este algoritmo es:

1. Cada vez que se encuentra la longitud de la ruta desde el nodo de origen a cada nodo, se saca la más corta. En este momento, no hay otra ruta más corta al nodo, y luego márquela para evitar la próxima visita.
2. Después de encontrar la ruta, actualice la ruta a otros nodos a través del nodo actual, pero no la marque.
3. Hasta que se encuentren todas las longitudes de ruta más cortas.

package graph.DijstraAlgorithm;

import java.util.Scanner;

public class DijstraAlgorithm {
    
    
   public static int Max_Value = 100000;//不能设置为Integer的最大值，防止数组越界

    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入图的顶点数和边数：");
        int vertex = scanner.nextInt();
        int edge = scanner.nextInt();

        int[][] martix = new int[vertex][vertex];

        //初始化图的关系矩阵
        for (int i = 0; i < vertex; i++) {
    
    
            for (int j = 0; j < vertex; j++) {
    
    
                martix[i][j] = Max_Value;
            }
        }
        //配置相应的边信息
        for (int i = 0; i < edge; i++) {
    
    
            System.out.println("第"+(i+1)+"条边及其权值：");
            int source = scanner.nextInt();
            int target = scanner.nextInt();
            int weight = scanner.nextInt();
            martix[source][target] = weight;
        }

        System.out.println("请输入出发点的序号（此序号应该大于0，小于"+vertex+":");
        int source = scanner.nextInt();
        dijstra(source,martix);

    }

    private static void dijstra(int source, int[][] martix) {
    
    
        //最短路径集合
        int[] shortest = new int[martix.length];
        //标记已经找到最短路径
        int[] visited = new int[martix.length];
        //记录到达各节点最短路径的路径长度
        String[] path = new String[martix.length];
        for (int i = 0; i < martix.length; i++) {
    
    
            path[i] = new String(source+"->"+i);
        }

        for (int i = 1; i < martix.length; i++) {
    
    
            int min = Integer.MAX_VALUE;
            int index = -1;

            for (int j = 0; j < martix.length; j++) {
    
    
                if(visited[j]==0&&martix[source][j]<min){
    
    
                    min = martix[source][j];
                    index = j;
                }
            }

            //更新到本次遍历过程中的最短路径
            visited[index] = 1;
            shortest[index] = min;

            //更新通过index节点到达其他节点的路径长度
            for (int j = 0; j < martix.length; j++) {
    
    
                if (visited[j]==0&&martix[source][index]+martix[index][j]<martix[source][j]){
    
    
                    martix[source][j] = martix[source][index]+martix[index][j];
                    path[j] = path[index]+"->"+j;
                }
            }
        }

        for (int i = 0; i < path.length; i++) {
    
    
            if (i!=source){
    
    
                if(shortest[i]<Max_Value){
    
    
                    System.out.println(source+"->"+i+"的路径为："+path[i]);
                }else {
    
    
                    System.out.println(source+"不能达到"+i);
                }
            }
        }
    }
}

1. El algoritmo de Dijstra no admite ponderaciones negativas, porque cada vez que se encuentre una ruta más corta, se marcará y su valor no se modificará. Sin embargo, cuando aparece un valor negativo, la ruta más corta original puede no ser la verdadera ruta más corta. El camino más corto se ha marcado en ese momento y no se puede modificar.
2. El peso inicial de la relación de nodo que se usa en este algoritmo es Max_Value, no el valor máximo de Integer, porque se agregará al calcular la ruta más corta del nodo, y si se usa este último, se desbordará.
3. El algoritmo de Dijstra es adecuado para encontrar la ruta más corta de un solo punto.