New implementation of Dijkstra

src/Task9.java

@@ -20,7 +20,7 @@ public class Task9 {
     List<Edge> edges = g.getShortestPath(0,3);
     System.out.println(startNumber);
     for (Edge edge: edges) {
-      System.out.println(edge.destination());
+      System.out.println(edge.getDestination());
     }
     System.out.println("----------------------- Dijkstra Done --------------------------------");
     g.loadNodes(Utils.generatePath("noder.txt"));
@@ -97,15 +97,41 @@ class Node{
   }
 }
 
-record Edge(int start, int destination, int drivingTime) implements Comparable<Edge> {
+class Edge implements  Comparable<Edge>{
+  int start;
+  int destination;
+  int drivingTime;
+  int currentWeight = 0;
 
-  @Override
-  public int compareTo(Edge o) {
-    return Integer.compare(this.drivingTime(), o.drivingTime());
+  Edge(int start, int destination, int drivingTime){
+    this.start = start;
+    this.destination = destination;
+    this.drivingTime = drivingTime;
   }
 
-  public int start() {
-    return this.start;
+  public int getStart() {
+    return start;
+  }
+
+  public int getDestination() {
+    return destination;
+  }
+
+  public int getDrivingTime() {
+    return drivingTime;
+  }
+
+  public int getCurrentWeight() {
+    return currentWeight;
+  }
+
+  public void setCurrentWeight(int currentWeight) {
+    this.currentWeight = currentWeight;
+  }
+
+  @Override
+  public int compareTo(Edge o) {
+    return Integer.compare(drivingTime+currentWeight,o.drivingTime+o.currentWeight);
   }
 }
 
@@ -153,28 +179,27 @@ class Graph{
     PriorityQueue<Edge> priorityQueue = new PriorityQueue<>();
     int nodeSize = adjacencyList.size();
     int[] pathWeight = new int[nodeSize];
-    boolean[] visited = new boolean[nodeSize];
     Arrays.fill(pathWeight, Integer.MAX_VALUE);
     ArrayList<Edge>[] pathToNodes = new ArrayList[nodeSize];
     pathWeight[startNumber] = 0;
-    visited[startNumber] = true;
     Arrays.fill(pathToNodes,new ArrayList<>());
     priorityQueue.addAll(adjacencyList.get(startNumber));
     while (!priorityQueue.isEmpty()){
       Edge nextEdge = priorityQueue.poll();
-      int nextNode = nextEdge.destination();
-      if(!visited[nextNode]){
-        int start = nextEdge.start();
-        int currentSum = pathWeight[start] + nextEdge.drivingTime();
+      int nextNode = nextEdge.getDestination();
+      int start = nextEdge.getStart();
+      int currentSum = pathWeight[start] + nextEdge.getDrivingTime();
       if(currentSum<pathWeight[nextNode]) {
-
         pathWeight[nextNode] = currentSum;
         pathToNodes[nextNode] = new ArrayList<>(pathToNodes[start]);
         pathToNodes[nextNode].add(nextEdge);
-          priorityQueue.addAll(adjacencyList.get(nextNode));
+        for(Edge edge: adjacencyList.get(nextNode)){
+          edge.setCurrentWeight(pathWeight[start]);
+          priorityQueue.add(edge);
         }
+        priorityQueue.addAll(adjacencyList.get(nextNode));
       }
-      if(visited[destinationNumber]) return pathToNodes[destinationNumber];
+      if(nextNode == destinationNumber) return pathToNodes[destinationNumber];
     }
     return pathToNodes[destinationNumber];
   }