Комментирование кода

package Graphs;// Пакет package позволяет логически объединить классы в наборы.
// Указываем, что класс принадлежит определенному пакету com.company
 
import java.util.HashMap; //Осуществляется импорт пакета HashMap
import java.util.Scanner;//Осуществляется импорт пакета Scanner
 
public class BellmanFord {
 
    public static class edge {
        int u;
        int v;
 
        public edge(int u, int v) {
            this.u = u;
            this.v = v;
        }
 
        public String toString() {
            return this.u + " " + this.v;
        }
    }
 
    public static class Node {
        int val;
        int dist;
        String path;
 
        public Node(int val, int dist, String path) {
            this.val = val;
            this.dist = dist;
            this.path = path;
        }
 
        public String toString() {
            return "Расстояние " + this.val + " от источника " + this.dist + " и путь следования " + this.path;
        }
 
    }
 
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int nodes = scn.nextInt();
        int[][] graph = new int[nodes + 1][nodes + 1];
        int numEdges = scn.nextInt();
        for (int edge = 0; edge < numEdges; edge++) {
            int u = scn.nextInt(), v = scn.nextInt(), w = scn.nextInt();
            graph[u][v] = w;
        }
 
        bellmanford(scn.nextInt(), nodes, numEdges, graph);
 
    }
 
    public static edge[] getEdges(int numEdges, int[][] graph) {
        edge[] rv = new edge[numEdges];
 
        int idx = 0;
        for (int u = 1; u < graph.length && idx < rv.length; u++) {
            for (int v = 1; v < graph[u].length && idx < rv.length; v++) {
                rv[idx] = new edge(u, v);
                idx = graph[u][v] != 0 ? idx + 1 : idx;
            }
        }
 
        return rv;
 
    }
 
    public static void bellmanford(int src, int nodes, int edges, int[][] graph) {
        /*
         * мы используем hashmap для хранения узлов каждой вершины,
         * (имя вершины, узел) будет ключ, пара значений
         */
        HashMap<Integer, Node> nodesMap = new HashMap<>();
        for (int i = 1; i < graph.length; i++) {
            /*
             * инициализируйте кратчайшее расстояние каждой вершины,
             *  равное бесконечности, так как для этой вершины самое
             *  короткое расстояние еще предстоит рассчитать, и
             *  инициализируйте пустой путь. Но если вершина сама является
             *  исходной, то кратчайшее расстояние для нее будет 0, и путь
             *  будет инициализирован с именем вершины.
             */
            nodesMap.put(i, new Node(i, i == src ? 0 : (int) 1e9 + 1, i == src ?
                    Integer.toString(i) : ""));
        }
 
        /* внешний цикл будет работать для вершин - 1 раз */
        for (int var = 1; var <= nodes - 1; var++) {
            /* запуск внутреннего цикла на множестве ребер,
             * возвращаемых функцией getEdges */
            for (edge e : getEdges(edges, graph)) {
                Node u = nodesMap.get(e.u);
                Node v = nodesMap.get(e.v);
 
                /*
                 * основное условие для обновления кратчайшего расстояния любого узла
                 */
                if (v.dist > u.dist + graph[u.val][v.val]) {
                    v.dist = u.dist + graph[u.val][v.val];
                    v.path = u.path + "->" + Integer.toString(v.val);
                }
            }
        }
 
        /*
         * еще один цикл в случайном наборе ребер,
         * чтобы определить, есть ли отрицательный цикл или нет
         */
        for (edge e : getEdges(edges, graph)) {
            Node u = nodesMap.get(e.u);
            Node v = nodesMap.get(e.v);
 
            /*
             * если мы все можем найти самое короткое расстояние,
             * это просто означает, что наверняка существует отрицательный
             * цикл, и, следовательно, мы возвращаемся из функции,
             * поскольку для такого графа невозможно найти кратчайшее
             * расстояние для каждой вершины от источника, поскольку мы
             * можем получить еще более короткое расстояние повторяя цикл
             * в этом отрицательном цикле.
             */
            if (v.dist > u.dist + graph[u.val][v.val]) {
                System.out.println("Обнаружен отрицательный цикл");
                return;
            }
        }
 
        for (int node : nodesMap.keySet()) {
            System.out.println(nodesMap.get(node));
        }
 
    }
 
}