Completed Dijkstra

Author: maykulkarni

Algorithms/Dijkstra.java

@@ -6,9 +6,11 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * Created by Uzumaki Naruto on 2/17/2017.
+ *
  */
 public class Dijkstra<T> {
     private Graph<T> graph;
@@ -17,15 +19,50 @@ public class Dijkstra<T> {
         this.graph = graph;
     }
 
+    public static void main(String[] args) {
+        Graph<Integer> graph = new Graph<>(4, false);
+        graph.addEdge(0, 1, 101);
+        graph.addEdge(0, 3, 1);
+        graph.addEdge(0, 2, 101);
+        graph.addEdge(1, 2, 1);
+        graph.addEdge(1, 3, 10);
+        graph.addEdge(2, 3, 10);
+        System.out.println(new Dijkstra<Integer>(graph).shortestPaths(0));
+    }
+
     public Map<T, Integer> shortestPaths(T from) {
         Heap<T> heap = new Heap<T>();
         Map<T, Integer> shortestPath = new HashMap<T, Integer>();
+        Set<T> verticesSet = graph.verticesSet();
+
+        // remove the initial from node
+        verticesSet.remove(from);
+
+        // Initially all are Infinity
         for (T node : graph.verticesSet()) {
             heap.add(new GraphNode<T>(node, Integer.MAX_VALUE));
         }
+
+        // update for initial node
         for (T adjNode : graph.adjacencyList(from)) {
             heap.alterPriority(adjNode, graph.edgeWeight(from, adjNode));
         }
-        return null;
+
+        while (!verticesSet.isEmpty()) {
+            GraphNode<T> curr = heap.poll();
+            shortestPath.put(curr.getNodeName(), curr.getWeight());
+            int minDistanceToCurrNode = curr.getWeight();
+            verticesSet.remove(curr.getNodeName());
+            for (T node : graph.adjacencyList(curr.getNodeName()))
+                if (verticesSet.contains(node)) {
+                    int currWeight = heap.getPriority(node);
+                    int candidateVal = minDistanceToCurrNode + graph.edgeWeight(curr.getNodeName(), node);
+                    if (currWeight > candidateVal) {
+                        heap.alterPriority(node, candidateVal);
+                    }
+                }
+        }
+
+        return shortestPath;
     }
 }

DataStructures/Graph.java

@@ -4,6 +4,7 @@
 
 /**
  * Created by Mayur Kulkarni on 2/5/2017.
+ *
  */
 public class Graph<T> implements Iterable<T> {
     /**
@@ -79,8 +80,8 @@ public int edgeWeight(T fromNode, T toNode) {
     /**
      * Inserts toNode to the adjacency list of fromNode
      *
-     * @param fromNode from node
-     * @param toNode   to node
+     * @param fromNode  from node
+     * @param toNode    to node
      */
     private void insertIntoGraphMap(T fromNode, T toNode) {
         graph.compute(fromNode, (key, value) -> {
@@ -137,7 +138,7 @@ public void addEdge(T fromNode, T toNode, int weight) {
     /**
      * Returns the adjacency list of the graph
      * @param key the index of node you're interested in
-     * @return adjacency list of node specifief in key
+     * @return adjacency list of node specific in key
      */
     public List<T> adjacencyList(T key) {
 
@@ -170,11 +171,11 @@ public Set<T> articulationPoints() {
      *  2. if current node is root node of DFS, and has more than 2 independent children
      * for more: https://adventinprogramming.wordpress.com/2017/02/05/articulation-points-in-graph/
      *
-     * @param visited denotes the nodes which are already visited
-     * @param visitedTime denotes the order in which nodes are visited
-     * @param currNode the current node of this traversa;
-     * @param lowTime denotes the minimum lowTime of adjacent vertices
-     * @param parent parent of the current node
+     * @param visited       denotes the nodes which are already visited
+     * @param visitedTime   denotes the order in which nodes are visited
+     * @param currNode      the current node of this traversal;
+     * @param lowTime       denotes the minimum lowTime of adjacent vertices
+     * @param parent        parent of the current node
      * @param articulationPoints articulation points of the current graph
      */
     public void DFSArticulationPoint(Set<T> visited,
@@ -198,10 +199,12 @@ public void DFSArticulationPoint(Set<T> visited,
                 if (visitedTime.get(currNode) <= lowTime.get(adjNode)) {
                     isArticulationPoint = true;
                 } else {
-                    lowTime.compute(currNode, (node, nodeLowTime) -> Math.min(lowTime.get(currNode), lowTime.get(adjNode)));
+                    lowTime.compute(currNode, (node, nodeLowTime) ->
+                            Math.min(lowTime.get(currNode), lowTime.get(adjNode)));
                 }
             } else {
-                lowTime.compute(currNode, (node, lowtime) -> Math.min(lowTime.get(currNode), lowTime.get(adjNode)));
+                lowTime.compute(currNode, (node, lowtime) ->
+                        Math.min(lowTime.get(currNode), lowTime.get(adjNode)));
             }
         }
         // first condition is satisfied only by root nodes of tarjanSCC, for rest of them there's
@@ -216,9 +219,9 @@ public void DFSArticulationPoint(Set<T> visited,
      * Tell whether the currNode is the root of the tarjanSCC or not.
      * The root of the tarjanSCC will have null as it's parent
      *
-     * @param currNode The node you're interested in
-     * @param parent   parent HashMap who's key is node and value is it's parent
-     * @return
+     * @param currNode  The node you're interested in
+     * @param parent    parent HashMap who's key is node and value is it's parent
+     * @return or not it is root
      */
     private boolean isRoot(T currNode, Map<T, T> parent) {
         return parent.get(currNode) == null;

Random/Demo.java

@@ -1,55 +1,33 @@
 package Random;
 
-
-import Utils.SearchUtils;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-
-/**
- * Created by mayur on 4/9/16.
- */
 public class Demo {
-    public static void main(String args[]) {
-        Random random = new Random();
-        List<Double> normal = new ArrayList<>();
-        List<Double> stream = new ArrayList<>();
-        for (int i = 0; i < 10000; i++) {
-            int size = random.nextInt(100000) + 10;
-            int[] arr = new int[size];
-            for (int j = 0; j < size; j++) {
-                arr[j] = random.nextInt(Integer.MAX_VALUE);
-            }
-            double startTime = System.currentTimeMillis();
-            int max = SearchUtils.maxInArray(arr);
-            double normalTime = System.currentTimeMillis() - startTime;
-            startTime = System.currentTimeMillis();
-            int maxStream = SearchUtils.maxInArrayStream(arr);
-            double streamTime = System.currentTimeMillis() - startTime;
-            assert max == maxStream;
-            normal.add(normalTime);
-            stream.add(streamTime);
-        }
-        printStatistics(normal, stream);
+    public static void main(String[] args) {
+        ListNode myList = new Demo().new ListNode();
+        myList.node = 1;
+        myList.next = new Demo().new ListNode();
+        myList.next.node = 2;
+        myList.next.next = new Demo().new ListNode();
+        myList.next.next.node = 3;
+        new Demo().reverse(null, myList);
+        System.out.println(myList.node + " " + myList.next.node + " " + myList.next.next.node);
     }
 
-    public static double average(List<Double> list) {
-        double sum = 0;
-        for (double a : list) {
-            sum += a;
+    public void reverse(ListNode prev, ListNode currNode) {
+        if (currNode == null) {
+            return;
+        } else {
+            reverse(currNode, currNode.next);
+            currNode.next = prev;
         }
-        return sum / list.size();
     }
 
-    private static void printStatistics(List<Double> normal, List<Double> stream) {
-        System.out.println("Normal: ");
-        System.out.println("Average: " + average(normal) + " ms");
-        System.out.println("Worst: " + normal.stream().mapToDouble((x) -> x).max().getAsDouble());
-        System.out.println("Best: " + normal.stream().mapToDouble((x) -> x).min().getAsDouble());
-        System.out.println("Stream: ");
-        System.out.println("Average: " + average(stream) + " ms");
-        System.out.println("Worst: " + stream.stream().mapToDouble((x) -> x).max().getAsDouble());
-        System.out.println("Best: " + stream.stream().mapToDouble((x) -> x).min().getAsDouble());
+    class ListNode {
+        int node;
+        ListNode next;
+
+        @Override
+        public String toString() {
+            return String.valueOf(this.node);
+        }
     }
-}
+}