Reworked Dijkstra

.idea/vcs.xml

@@ -2,5 +2,6 @@
 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/oving-9" vcs="Git" />
   </component>
 </project>
\ No newline at end of file

src/Task9.java

@@ -6,19 +6,17 @@ import java.util.*;
 
 public class Task9 {
   public static void main(String[] args) {
-    Graph graph = new Graph();
-    graph.readAllNodes(Utils.readFile(Utils.generatePath("noder.txt")));
-    graph.readAllEdges(Utils.readFile(Utils.generatePath("kanter.txt")));
-    List<Edge> edges = Dijkstra.getShortestPath(graph,0,3);
-    int sum = 0;
-    Node node = graph.getNode(edges.get(0).getStart());
-    System.out.println(node.getLongitude()+","+ node.getLatitude());
+
+    Graph g = new Graph("noder Iceland.txt");
+    g.loadEdges("kanterIceland.txt");
+    int startNumber = 0;
+    List<Edge> edges = Dijkstra.getShortestPath(g,startNumber,3);
+    Node node = g.getNode(startNumber);
+    System.out.println(node.getLatitude() + "," +  node.getLongitude());
     for(Edge edge: edges){
-      Node destination = graph.getNode(edge.getDestination());
-      System.out.println(destination.getLongitude()+","+ destination.getLatitude());
-      sum+= edge.getDrivingTime();
+      node = g.getNode(edge.destination());
+      System.out.println(node.getLatitude() + "," +  node.getLongitude());
     }
-    System.out.println("Final driving time is " + sum);
   }
 }
 class Node{
@@ -27,7 +25,8 @@ class Node{
   private final double longitude;
   private String[] typeArray;
   private String name;
-  private final List<Edge> edges = new ArrayList<>();
+  //private final List<Edge> edges = new ArrayList<>();
+
   public Node(int number, double latitude, double longitude) {
     this.number = number;
     this.latitude = latitude;
@@ -54,10 +53,6 @@ class Node{
     return name;
   }
 
-  public List<Edge> getEdges() {
-    return edges;
-  }
-
   public void setName(String name){
     this.name=name;
   }
@@ -78,9 +73,9 @@ class Node{
     }
   }
 
-  public void addEdge(int destination, int drivingTime, int distance, int speedLimit){
+  /*public void addEdge(int destination, int drivingTime, int distance, int speedLimit){
     edges.add(new Edge(this.getNumber(),destination,drivingTime,distance,speedLimit));
-  }
+  }*/
 
   public boolean isTypeOf(String typeName){
     return Arrays.stream(typeArray).anyMatch(t -> t.equalsIgnoreCase(typeName));
@@ -99,90 +94,70 @@ class Node{
   }
 }
 
-class Edge implements Comparable<Edge> {
-  private final int start;
-  private final int destination;
-  private final int drivingTime;
-  private final int distance;
-  private final int speedLimit;
+record Edge(int start, int destination, int drivingTime) implements Comparable<Edge> {
 
-  public Edge(int start, int destination, int drivingTime, int distance, int speedLimit) {
-    this.start = start;
-    this.destination = destination;
-    this.drivingTime = drivingTime;
-    this.distance = distance;
-    this.speedLimit = speedLimit;
-  }
-
-  public int getStart() {
-    return start;
+  @Override
+  public int compareTo(Edge o) {
+    return Integer.compare(this.drivingTime(), o.drivingTime());
   }
 
-  public int getDestination() {
-    return destination;
+  public int start() {
+    return this.start;
   }
-
-  public int getDrivingTime() {
-    return drivingTime;
 }
 
-  public int getDistance() {
-    return distance;
-  }
-
-  public int getSpeedLimit() {
-    return speedLimit;
-  }
+class Graph{
+  private final List<Node> nodes;
+  private final HashMap<Integer, List<Edge>> adjacencyList = new HashMap<>();
 
-  @Override
-  public int compareTo(Edge o) {
-    return Integer.compare(this.getDrivingTime(),o.getDrivingTime());
+  public Graph(String inFile) {
+    nodes = loadNodes(inFile);
+    for(int i = 0; i < nodes.size(); ++i) {
+      adjacencyList.put(i, new ArrayList<>());
     }
   }
 
-class Graph{
-  private final List<Node> nodes = new ArrayList<>();
-
-
-  public void setNodes(int number, double longitude, double latitude){
-    nodes.add(number, new Node(number,latitude,longitude));
+  public List<Node> loadNodes(String inFile) {
+    List<Node> nodes = new ArrayList<>();
+    List<String> data = Utils.readFile(inFile);
+    for(int i = 1; i < data.size(); ++i) {
+      String[] splitText = Utils.dividedText(data.get(i), 3);
+      nodes.add(new Node(Integer.parseInt(splitText[0]), Double.parseDouble(splitText[1]), Double.parseDouble(splitText[2])));
     }
-
-  public Node getNode(int index){
-    return nodes.get(index);
+    System.out.println("Nodes loaded.");
+    return nodes;
   }
 
-  public void readAllNodes(List<String> data){
-    for (int i = 1; i<data.size(); i++){
-      //System.out.println(data.get(i));
+  public void loadEdges(String inFile) {
+    List<String> data = Utils.readFile(inFile);
+    for(int i = 1; i < data.size(); ++i) {
       String[] splitText = Utils.dividedText(data.get(i), 3);
-      //System.out.println(Arrays.toString(splitText));
-      this.setNodes(Integer.parseInt(splitText[0]),Double.parseDouble(splitText[1]),Double.parseDouble(splitText[2]));
+      addEdge(Integer.parseInt(splitText[0]), Integer.parseInt(splitText[1]), Integer.parseInt(splitText[2]));
     }
+    System.out.println("Edges loaded.");
   }
 
-  /**Possible fail*/
-  public void readAllEdges(List<String> data){
-    for(int i = 1 ; i<data.size();i++){
-      String [] splitText = Utils.dividedText(data.get(i),5);
-      //     System.out.println(Arrays.toString(splitText));
-      this.getNode(Integer.parseInt(splitText[0])).
-          addEdge(Integer.parseInt(splitText[1])
-              ,Integer.parseInt(splitText[2]),Integer.parseInt(splitText[3])
-              ,Integer.parseInt(splitText[4]));
+  public void addEdge(int start, int destination, int drivingTime) {
+    adjacencyList.get(start).add(new Edge(start,destination, drivingTime));
   }
+
+  public Node getNode(int nodeNumber){
+    return nodes.get(nodeNumber);
   }
 
-  public void readNodeInformation(List<String> data){
+  public List<Edge> getAllEdgesFromNode(int nodeNumber){
+    return adjacencyList.get(nodeNumber);
+  }
+  /*public void readNodeInformation(List<String> data){
     for(String text : data){
       if(!text.equals(data.get(0))){
         String [] splitText = Utils.dividedText(text,3);
         this.setTypes(Integer.parseInt(splitText[0]),Integer.parseInt(splitText[1]),splitText[2]);
       }
     }
-  }
+  }*/
 
-  private void setTypes(int nodeNumber,int typeValue, String name){
+  /*private void setTypes(int nodeNumber,int typeValue, String name){
     Node node = this.getNode(nodeNumber);
 
     if((typeValue&1) ==1) node.setType("Place name");
@@ -193,7 +168,7 @@ class Graph{
     if((typeValue&32) == 32) node.setType("Accommodation");
 
     node.setName(name);
-  }
+  }*/
 
   public int getNumberOfNodes(){
     return nodes.size();
@@ -212,8 +187,30 @@ class Graph{
   }
 }
 
+
 class Dijkstra{
   public static List<Edge> getShortestPath(Graph graph, int startNumber, int destinationNumber){
+    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>();
+    int[] pathWeight = new int[graph.getNumberOfNodes()];
+    Arrays.fill(pathWeight, Integer.MAX_VALUE);
+    List<Edge>[] pathToNodes = new List[graph.getNumberOfNodes()];
+    pathWeight[startNumber] = 0;
+    Arrays.fill(pathToNodes,new ArrayList<>());
+    priorityQueue.addAll(graph.getAllEdgesFromNode(startNumber));
+    while (!priorityQueue.isEmpty()){
+      Edge nextEdge = priorityQueue.poll();
+      int nextNode = nextEdge.destination();
+      int currentSum = pathWeight[nextEdge.start()] + nextEdge.drivingTime();
+      if(currentSum<pathWeight[nextNode]){
+        pathWeight[nextNode] = currentSum;
+        pathToNodes[nextNode] = new ArrayList<>(pathToNodes[nextEdge.start()]);
+        pathToNodes[nextNode].add(nextEdge);
+        priorityQueue.addAll(graph.getAllEdgesFromNode(nextNode));
+      }
+    }
+    return pathToNodes[destinationNumber];
+  }
+  /*public static List<Edge> getShortestPath(Graph graph, int startNumber, int destinationNumber){
     PriorityQueue<Edge> priorityQueue = new PriorityQueue<>();
     Node startNode = graph.getNode(startNumber);
     //boolean[] visitedNodes = new boolean[graph.getNumberOfNodes()];
@@ -227,18 +224,18 @@ class Dijkstra{
     System.out.println("Debugging");
     while (!priorityQueue.isEmpty()){
       Edge nextEdge = priorityQueue.poll();
-      int nextNode = nextEdge.getDestination();
-      int currentSum = pathWeight[nextEdge.getStart()] + nextEdge.getDrivingTime();
+      int nextNode = nextEdge.destination();
+      int currentSum = pathWeight[nextEdge.start()] + nextEdge.drivingTime();
       if(currentSum < pathWeight[nextNode]){
         pathWeight[nextNode] = currentSum;
-        pathToNodes[nextNode] = new ArrayList<>(pathToNodes[nextEdge.getStart()]);
+        pathToNodes[nextNode] = new ArrayList<>(pathToNodes[nextEdge.start()]);
         //pathToNodes[nextNode.getNumber()].addAll(pathToNodes[nextEdge.getStart().getNumber()]);
         pathToNodes[nextNode].add(nextEdge);
         priorityQueue.addAll( graph.getNode(nextNode).getEdges());
       }
     }
     return pathToNodes[destinationNumber];
-  }
+  }*/
 /*
   public static ListOfPlaces getClosePlaces(Graph graph, int startNumber, String typOfPlace, int numberOfPlaces){
     ListOfPlaces listOfPlaces = new ListOfPlaces(numberOfPlaces);

src/Trying.java

 import java.util.*;
 
 public class Trying {
+  public static void main(String[] args) {
+    NewGraph graph = new NewGraph();
+    System.out.println("Reading Nodes");
+    graph.readAllNodes(Utils.readFile(Utils.generatePath("noder.txt")));
+    System.out.println("Reading edges");
+    graph.readAllEdges(Utils.readFile(Utils.generatePath("kanter.txt")));
+    System.out.println("Finished");
+  }
 }
 
 class NewNode {
@@ -115,7 +123,12 @@ class NewEdge implements Comparable<NewEdge>{
 
 class NewGraph{
   private final List<Node> nodes = new ArrayList<>();
-  private final Map<Integer,List<Edge>> graph = new HashMap<>();
+  private final List<List<NewEdge>> neighbourList = new ArrayList<>();
+
+  public void setNodes(int number, double longitude, double latitude){
+    nodes.add(number, new Node(number,latitude,longitude));
+  }
+
   public void readAllNodes(List<String> data){
     for (int i = 1; i<data.size(); i++){
       //System.out.println(data.get(i));
@@ -124,4 +137,18 @@ class NewGraph{
       this.setNodes(Integer.parseInt(splitText[0]),Double.parseDouble(splitText[1]),Double.parseDouble(splitText[2]));
     }
   }
+
+  public void readAllEdges(List<String> data){
+    for(int j = 0; j < Integer.parseInt(Utils.splitText(data.get(0),1)[0]);j++){
+      neighbourList.add(new ArrayList<>());
+    }
+    for(int i = 1 ; i<data.size();i++){
+      String [] splitText = Utils.dividedText(data.get(i),5);
+      neighbourList.get(i-1).add(new NewEdge(Integer.parseInt(splitText[0]),Integer.parseInt(splitText[1])
+          ,Integer.parseInt(splitText[2]),Integer.parseInt(splitText[3])
+          ,Integer.parseInt(splitText[4])));
+    }
+  }
+
+
 }