Dijkstra y encontrar ciclos en grafos dirigidos

import java.util.*;

public class Dijkstra {
  // Encontrar ciclos en grafos dirigidos
  // vis inicia lleno de 0s
  private void dfs(int u, ArrayList<Integer>[] g, int[] vis) {
    // Entrando
    vis[u] = 1;
    for (int v : g[u]) {
      if (vis[v] == 0)  {
        dfs(v, g, vis);
      }
      if (vis[v] == 1) {
        // Hay ciclo
      }
    }
    // Saliendo
    vis[u] = 2;
  }

  public static void main(String[] args) {
    Dijkstra sol = new Dijkstra();
    sol.solve();
  }

  class Arista {
    private int origen, destino, peso;

    public Arista(int origen, int destino, int peso) {
      this.origen = origen;
      this.destino = destino;
      this.peso = peso;
    }

    public int getOrigen()  {return origen;}
    public int getDestino() {return destino;}
    public int getPeso()    {return peso;}
  }

  public void solve() {
    Scanner sc = new Scanner(System.in);
    int n, m;
    n = sc.nextInt();
    m = sc.nextInt();
    ArrayList<Arista>[] g = new ArrayList[n];
    for (int i = 0; i < n; i++) {
      g[i] = new ArrayList<>();
    }
    for (int i = 0; i < m; i++) {
      int a, b, w;
      a = sc.nextInt();
      b = sc.nextInt();
      w = sc.nextInt();
      g[a].add(new Arista(a, b, w));
      g[b].add(new Arista(b, a, w));
    }
    // DESDE AQUI ES DIJKSTRA
    int[] dist = new int[n];
    int[] par = new int[n];
    ArrayList<Integer> nodosAlcanzados = new ArrayList<>();
    // Inicializacion
    int inicio = 0;
    int inf = 123456789;
    for (int i = 0; i < n; i++) {
      dist[i] = inf;
    }
    dist[inicio] = 0;
    par[inicio] = -1;
    nodosAlcanzados.add(inicio);
    // Encontrar caminos minimos
    while (nodosAlcanzados.size() > 0) {
      int u = nodoMenorDistancia(nodosAlcanzados, dist);
      nodosAlcanzados.remove(Integer.valueOf(u)); // eliminar u de la lista
      System.out.println("Distancia de " + inicio + " a " + u + " = " + dist[u]);
      for (Arista a : g[u]) {
        int v = a.getDestino();
        int w = a.getPeso();
        if (dist[u] + w < dist[v]) {
          dist[v] = dist[u] + w;
          par[v] = u;
          if (nodosAlcanzados.contains(v)) nodosAlcanzados.remove(Integer.valueOf(v));
          nodosAlcanzados.add(v);
        }
      }
    }
    System.out.println("Caminos!");
    for (int i = 0; i < n; i++) {
      System.out.println("Camino hasta " + i);
      ArrayList<Integer> camino = new ArrayList<>();
      int u = i;
      while (u != -1) {
        camino.add(u);
        u = par[u];
      }
      for (int j = camino.size()-1; j >= 0; j--) {
        System.out.print(camino.get(j) + " ");
      }
      System.out.println();
    }
  }

  private int nodoMenorDistancia(ArrayList<Integer> nodos, int[] dist) {
    int minDist = 123456789;
    int minNodo = -1;
    for (int u : nodos) {
      if (dist[u] < minDist) {
        minDist = dist[u];
        minNodo = u;
      }
    }
    return minNodo;
  }
}