I am doing a degree project for an aerial capital system and when it came to testing the codes in the test, the values ​​were outside the range, meaning they were infinite.I am doing a degree project for an aerial capital system and when it came to testing the codes in the test the values ​​were outside the range, meaning they were infinite. So I ordered the Floyd matrix to be printed and indeed they were at very high values. I mean infinite but I don't understand why everything is well entered and connected including the edges

public class Test {
    public static void main(String[] args) {
        Grafo<Capitales, Integer> gra = crearGrafo();
        Capitales capital = gra.obtvertices(1);
        System.out.println(capital);
        gra.mostrar();
        List<Capitales> caminoMinimo = caminoMinimoDesde(gra, 1, 0);
        System.out.println("Camino minimo: " + caminoMinimo);
        //Floyd f = new Floyd(gra);
        //Floyd2 fi=new Floyd2();
        //System.out.println(""+fi.algoritmoFloyd(gra));
        //System.out.println("" + f.toString());
        
    }

    private static Grafo<Capitales, Integer> crearGrafo() {
        Grafo<Capitales, Integer> gra = new Grafomulti<>(Integer.MAX_VALUE);
        ArrayList<Capitales> capitales = listaCapitales();
        for (Capitales capital : capitales) {
            gra.invertices(capital);
        }

        // Conexiones entre las capitales
        gra.inArista(0, 1, 1264); // Madrid to Paris
        gra.inArista(0, 2, 1871); // Madrid to Berlin
        gra.inArista(0, 3, 5783); // Madrid to Washington, D.C.
        gra.inArista(0, 4, 10965); // Madrid to Beijing

        gra.inArista(1, 2, 1050); // Paris to Berlin
        gra.inArista(1, 3, 6172); // Paris to Washington, D.C.
        gra.inArista(1, 4, 8200); // Paris to Beijing

        gra.inArista(2, 3, 6593); // Berlin to Washington, D.C.
        gra.inArista(2, 4, 7362); // Berlin to Beijing

        gra.inArista(3, 4, 11206); // Washington, D.C. to Beijing
        gra.inArista(3, 5, 3652); // Washington, D.C. to Ottawa

        gra.inArista(4, 5, 10430); // Beijing to Ottawa
        gra.inArista(4, 6, 13000); // Beijing to Canberra

        gra.inArista(5, 6, 15700); // Ottawa to Canberra
        return gra;
    }

    private static ArrayList<Capitales> listaCapitales() {
        ArrayList<Capitales> capitales = new ArrayList<>();
        Aeropuerto aeropuerto1 = new Aeropuerto("Viva air", 78236);
        Capitales Madrid = new Capitales("Madrid", aeropuerto1);
        

        Aeropuerto aeropuerto2 = new Aeropuerto("Avianca", 45678);
        Capitales Paris = new Capitales("Paris", aeropuerto2);

        Aeropuerto aeropuerto3 = new Aeropuerto("Avianca", 31468);
        Capitales Berlin = new Capitales("Berlin", aeropuerto3);

        Aeropuerto aeropuerto4 = new Aeropuerto("Avianca", 64215);
        Capitales Washington = new Capitales("Washington, D.C.", aeropuerto4);

        Aeropuerto aeropuerto5 = new Aeropuerto("Avianca", 95236);
        Capitales Beijing = new Capitales("Beijing", aeropuerto5);

        Aeropuerto aeropuerto6 = new Aeropuerto("Avianca", 10235);
        Capitales Ottawa = new Capitales("Ottawa", aeropuerto6);

        Collections.addAll(capitales, Madrid, Paris, Berlin, Washington, Beijing, Ottawa);
        return capitales;
    }
    
    

    public static Capitales rutaminima(Grafo<Capitales,Integer> g,int x){
        Floyd flo = new Floyd(g);
        Capitales b = null;
        ArrayList<Integer> a = new ArrayList<>();
        for (int i = 0; i < g.orden(); i++) {
            if(i==x){
                for (int j = 0; j < g.orden(); j++) {
                    a.add(flo.getF()[i][j]);
                }
            }
        }
        b=g.obtvertices(menor(a, g));
        
        return b;
    }

    private static int menor(ArrayList<Integer> Dis, Grafo<Capitales, Integer> g) {
        int menor=900;
        int indice=0;
        for (int i = 0; i < g.orden(); i++) {
            if(g.obtvertices(i).getAeropuerto() != null){
                if(Dis.get(i)<menor){
                menor=Dis.get(i);
                indice=i;
                }
            }
        }  return indice;
    }
        
    public static List<Capitales> caminoMinimoDesde(Grafo<Capitales, Integer> g, int ciudadOrigen, int ciudadDestino) {
        Floyd2 floyd = new Floyd2();
        String resultado = floyd.algoritmoFloyd(g);

        // Imprimir la matriz de caminos más cortos y los caminos entre vértices
        System.out.println(resultado);

        // Obtener el camino mínimo entre las ciudades
        List<Capitales> camino = new ArrayList<>();
        camino.add(g.obtvertices(ciudadOrigen)); // Agregamos la ciudad de origen al camino
        reconstruirCamino(ciudadOrigen, ciudadDestino, resultado, camino, g);
        return camino;
    }
    
    private static void reconstruirCamino(int ciudadOrigen, int ciudadDestino, String resultado, List<Capitales> camino, Grafo<Capitales, Integer> g) {
    // Dividimos el resultado en líneas para procesarlo
    String[] lineas = resultado.split("n");

    // Iteramos sobre las líneas para encontrar los caminos
    for (String linea : lineas) {
        // Si la línea contiene el formato "de (x---->y)", es un camino entre dos ciudades
        if (linea.startsWith("de")) {
            // Extraemos los índices de las ciudades desde la cadena
            int inicioIndice = linea.indexOf("(") + 1;
            int finIndice = linea.indexOf("---->");
            int indiceOrigen = Integer.parseInt(linea.substring(inicioIndice, finIndice)) - 1;
            inicioIndice = finIndice + 5;
            finIndice = linea.indexOf(")");
            int indiceDestino = Integer.parseInt(linea.substring(inicioIndice, finIndice)) - 1;

            // Si las ciudades coinciden con las de origen y destino que buscamos, agregamos al camino
            if (indiceOrigen == ciudadOrigen && indiceDestino == ciudadDestino) {
                camino.add(g.obtvertices(ciudadDestino));
                return;
            }
        }
    }
}

`Capitales{capital=Paris, Aeropuerto=Aeropuerto{aerolinea=Avianca, id_avion=45678}}
Capitales{capital=Madrid, Aeropuerto=Aeropuerto{aerolinea=Viva air, id_avion=78236}} ->
Capitales{capital=Paris, Aeropuerto=Aeropuerto{aerolinea=Avianca, id_avion=45678}} ->
Capitales{capital=Berlin, Aeropuerto=Aeropuerto{aerolinea=Avianca, id_avion=31468}} ->
Capitales{capital=Washington, D.C., Aeropuerto=Aeropuerto{aerolinea=Avianca, id_avion=64215}} ->
Capitales{capital=Beijing, Aeropuerto=Aeropuerto{aerolinea=Avianca, id_avion=95236}} ->
Capitales{capital=Ottawa, Aeropuerto=Aeropuerto{aerolinea=Avianca, id_avion=10235}} ->

LOS DIFERENTES CAMINOS MAS CORTOS ENTRE VERTICES SON:

Camino minimo: [Capitales{capital=Paris, Aeropuerto=Aeropuerto{aerolinea=Avianca, id_avion=45678}}]
-6222 2147477423 2147477405 2147477297 2147476649 2147472761
2147477423your text -6228 -6246 -6354 -7002 -10890
2147477405 -6246 -6264 -6372 -7020 -10908
2147477297 -6354 -6372 -6480 -7128 -11016
2147476649 -7002 -7020 -7128 -7776 -11664
2147472761 -10890 -10908 -11016 -11664 -15552
At first everything was fine because it returned the capitals to me but then it returned the Floyd matrix with very high values.`