Djikstra

package Djikstra;

import java.io.IOException;
import java.util.ArrayList;
import IO.*;

public class Djikstra
{
    private ArrayList<ArrayList<Integer>> mat = new ArrayList<ArrayList<Integer>>();
    private int nodi;
    private int src;
    private IO io;

    public Djikstra()
    {
        io = new IO (); //Funzioni di input e output
    }

    /**
     *
     * @param mat   Matrice di adiacenza del grafo
     * @param nodi  Numero di nodi sel grafo
     * @param src   Nodo del grafo di raggiungere
     */
    public Djikstra(ArrayList<ArrayList<Integer>> mat, int nodi, int src)
    {
        io = new IO (); //Funzioni di input e output
        this.mat = mat;
        this.nodi = nodi;
        this.src = src;
    }


    // Funzione per trovare il vertice con distanza minima tra tutti gli altri vertici
    public int minDistanza(ArrayList<Integer> dist, ArrayList<Boolean> visitato)
    {

        int min = Integer.MAX_VALUE, min_index = -1;

        //Trovo il vertice con distanza minima
        for (int v = 0; v < this.nodi; v++)
            if (visitato.get(v) == false && dist.get(v) <= min) {
                min = dist.get(v);
                min_index = v;
            }

        return min_index;
    }


    public void stampaSoluzione(ArrayList<Integer> dist)
    {
        System.out.println("\n\nVertice   \tDistanza dal nodo sorgente ("+(this.src+1)+")");
        for (int i = 0; i < this.nodi; i++)
            System.out.println( (i+1) + " \t\t " + dist.get(i));
    }

    /**
     * Funzione che implementa l'algoritmo di djikstra
     */
    public void dijkstra()
    {
        ArrayList<Integer> dist = new ArrayList<Integer>(this.nodi); // Includerà le distanze dal vertice al vertice sorgente

        ArrayList<Boolean> visitato = new ArrayList<Boolean>(this.nodi); // visitato[i] sarò true se ho visitato il vertice, false altrimenti

        for (int i = 0; i < this.nodi; i++) {
            dist.add(i,Integer.MAX_VALUE);
            visitato.add(i, false);
        }

        //La distanza da un vertice al vertice stesso è 0
        dist.set(this.src,0);

     // In questo ciclo trovo il cammino minimo
        for (int count = 0; count < this.nodi - 1; count++)
        {
            // Prendo la distanza minima dei vertici che non ho visitato
            int min = minDistanza(dist, visitato);

            //Mi segno che l'ho visitato
            visitato.set(min,true);

            //Aggiorno la distanza del vertice adiacente partendo dal vertice che ho preso
            for (int v = 0; v < this.nodi; v++)
            {
                // Agggiorno la distanza solo se non ho visitato il vertice e se le altre condizioni sono verificate
                if (!visitato.get(v) && this.mat.get(min).get(v) != 0 && dist.get(min) != Integer.MAX_VALUE && dist.get(min) + this.mat.get(min).get(v) < dist.get(v))
                    dist.set(v, dist.get(min) + this.mat.get(min).get(v));
            }


        }

        stampaSoluzione(dist);
    }

}