graphnode main v2

import java.util.*;

class GraphNode {
    private int id;
    private Map<GraphNode, Integer> neighbors;

    public GraphNode(int id) {
        this.id = id;
        this.neighbors = new HashMap<>();
    }

    public int getId() {
        return id;
    }

    public Map<GraphNode, Integer> getNeighbors() {
        return neighbors;
    }

    public void addNeighbor(GraphNode neighbor, int weight) {
        neighbors.put(neighbor, weight);
    }

    // ...

    // Bellman-Ford algorithm
    public Map<GraphNode, Integer> bellmanFordShortestPaths(GraphNode source) {
        Map<GraphNode, Integer> distanceMap = new HashMap<>();
        Map<GraphNode, List<GraphNode>> shortestPaths = new HashMap<>();

        for (GraphNode node : getAllNodes()) {
            distanceMap.put(node, Integer.MAX_VALUE);
            shortestPaths.put(node, new ArrayList<>());
        }

        distanceMap.put(source, 0);
        shortestPaths.get(source).add(source);

        for (int i = 0; i < getAllNodes().size() - 1; i++) {
            for (GraphNode node : getAllNodes()) {
                for (Map.Entry<GraphNode, Integer> neighborEntry : node.getNeighbors().entrySet()) {
                    int newDistance = distanceMap.get(node) + neighborEntry.getValue();
                    if (newDistance < distanceMap.get(neighborEntry.getKey())) {
                        distanceMap.put(neighborEntry.getKey(), newDistance);
                        shortestPaths.get(neighborEntry.getKey()).clear();
                        shortestPaths.get(neighborEntry.getKey()).addAll(shortestPaths.get(node));
                        shortestPaths.get(neighborEntry.getKey()).add(neighborEntry.getKey());
                    }
                }
            }
        }

        printShortestPaths(distanceMap, shortestPaths);

        return distanceMap;
    }

    private void printShortestPaths(Map<GraphNode, Integer> distanceMap, Map<GraphNode, List<GraphNode>> shortestPaths) {
        System.out.println("s d dist path");
        System.out.println("---- ---- ------------ -------------------");

        List<GraphNode> sortedNodes = new ArrayList<>(getAllNodes());
        sortedNodes.sort(Comparator.comparingInt(GraphNode::getId));

        for (GraphNode node : sortedNodes) {
            System.out.printf("%d %d %.4f %s%n", getId(), node.getId(), distanceMap.get(node) / 1.0,
                    buildPathString(shortestPaths.get(node)));
        }
    }

    private String buildPathString(List<GraphNode> path) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < path.size(); i++) {
            sb.append(path.get(i).getId());
            if (i < path.size() - 1) {
                sb.append("->");
            }
        }
        return sb.toString();
    }

    // Helper method to get all nodes in the graph
    private Set<GraphNode> getAllNodes() {
        Set<GraphNode> allNodes = new HashSet<>();
        collectNodes(this, allNodes);
        return allNodes;
    }

    private void collectNodes(GraphNode node, Set<GraphNode> allNodes) {
        if (!allNodes.contains(node)) {
            allNodes.add(node);
            for (GraphNode neighbor : node.getNeighbors().keySet()) {
                collectNodes(neighbor, allNodes);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        GraphNode node0 = new GraphNode(0);
        GraphNode node1 = new GraphNode(1);
        GraphNode node2 = new GraphNode(2);
        GraphNode node3 = new GraphNode(3);
        GraphNode node4 = new GraphNode(4);
        GraphNode node5 = new GraphNode(5);
        GraphNode node6 = new GraphNode(6);
        GraphNode node7 = new GraphNode(7);
        GraphNode node8 = new GraphNode(8);
        GraphNode node9 = new GraphNode(9);
        GraphNode node10 = new GraphNode(10);
        GraphNode node11 = new GraphNode(11);

        node0.addNeighbor(node1, 1);

        node1.addNeighbor(node11, 1);
        node1.addNeighbor(node5, 4);
        node1.addNeighbor(node4, 1);

        node2.addNeighbor(node8, 1);
        node2.addNeighbor(node5, 1);

        node5.addNeighbor(node6, 1);

        node11.addNeighbor(node8, 1);

        node6.addNeighbor(node3, 1);
        node6.addNeighbor(node4, 1);

        node4.addNeighbor(node7, 1);

        node7.addNeighbor(node9, 1);

        node9.addNeighbor(node10, 1);
        node9.addNeighbor(node3, 1);

        node10.addNeighbor(node3, 1);

        node0.bellmanFordShortestPaths(node0);
        node1.bellmanFordShortestPaths(node1);
        node2.bellmanFordShortestPaths(node2);
        node3.bellmanFordShortestPaths(node3);
        node4.bellmanFordShortestPaths(node4);
    }
}