added dijkstra algorithm

Author: Morfly

src/java/sequential/graph/dfs/RecursiveDepthFirstTraversal.java

@@ -17,7 +17,7 @@ public synchronized Collection<T> dfs(Map<T, List<T>> graph, T root) {
         explored = new LinkedHashSet<>();
 
         var traversed = explore(root);
-        
+
         clear();
         return traversed;
     }
@@ -37,6 +37,7 @@ private void clear() {
         graph = null;
     }
 
+
     public static void main(String[] args) {
         var graph = Map.of(
                 "you", List.of("alice", "bob", "clair"),

src/java/sequential/graph/dijkstra/BUILD

@@ -0,0 +1,5 @@
+java_binary(
+    name = "dijkstra",
+    main_class = "sequential.graph.dijkstra.Dijkstra",
+    srcs = glob(["*.java"]),
+)

src/java/sequential/graph/dijkstra/Dijkstra.java

@@ -0,0 +1,84 @@
+package sequential.graph.dijkstra;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+
+class Dijkstra<T> {
+
+    private static final double INFINITY = Double.POSITIVE_INFINITY;
+
+
+    public static <T> List<T> dijkstra(Map<T, Map<T, Double>> graph, T root, T target) {
+        var rootSuccessors = graph.getOrDefault(root, Map.of());
+
+        var costs = new HashMap<>(rootSuccessors);
+        var explored = new HashSet<T>();
+        var parents = new HashMap<T, T>();
+        for (var node : rootSuccessors.keySet())
+            parents.put(node, root);
+
+        var node = findMinCostNode(costs, explored);
+        while (node != null) {
+            explored.add(node);
+            var nodeCost = costs.get(node);
+
+            var successors = graph.getOrDefault(node, Map.of());
+
+            for (var succ : successors.keySet()) {
+                var edgeWeight = successors.get(succ);
+                if (nodeCost + edgeWeight < costs.getOrDefault(succ, INFINITY)) {
+                    costs.put(succ, nodeCost + edgeWeight);
+                    parents.put(succ, node);
+                }
+            }
+            node = findMinCostNode(costs, explored);
+        }
+
+        return buildPathToNode(target, parents);
+    }
+
+    private static <T> T findMinCostNode(Map<T, Double> costs, Set<T> explored) {
+        var minCost = INFINITY;
+        T minCostNode = null;
+        for (var node : costs.keySet()) {
+            var cost = costs.get(node);
+            if (!explored.contains(node) && cost < minCost) {
+                minCost = cost;
+                minCostNode = node;
+            }
+        }
+        return minCostNode;
+    }
+
+    private static <T> List<T> buildPathToNode(T target, Map<T, T> parents) {
+        if (!parents.containsKey(target))
+            throw new IllegalArgumentException("Invalid arguments provided.");
+
+        var path = new LinkedList<T>();
+        T node = target;
+        while (node != null) {
+            path.add(0, node);
+            node = parents.get(node);
+        }
+        return path;
+    }
+
+
+    public static void main(String[] args) {
+        var graph = Map.of(
+                "Start", Map.of("A", 5.0),
+                "A", Map.of("B", 7.0, "C", 4.0),
+                "B", Map.of("Finish", 4.0),
+                "C", Map.of("Finish", 3.0)
+        );
+
+        System.out.println(
+                dijkstra(graph, "Start", "Finish")
+        );
+    }
+}

src/java/sequential/graph/dijkstra/README.md

@@ -23,8 +23,9 @@ fun <T> Graph<T>.dijkstra(root: T, target: T): Collection<T> {
     val explored = mutableSetOf<T>()
     val parents = graph[root].orEmpty().mapValues { root }.toMutableMap()
 
-    var node = costs.minCostNode(explored)
+    var node = costs.findMinCostNode(explored)
     while (node != null) {
+        explored += node
         val nodeCost = costs[node]!!
 
         val successors = graph[node].orEmpty()
@@ -34,32 +35,27 @@ fun <T> Graph<T>.dijkstra(root: T, target: T): Collection<T> {
                 parents[succ] = node
             }
         }
-        explored += node
-        node = costs.minCostNode(explored)
+        node = costs.findMinCostNode(explored)
     }
 
-    return pathToNode(target, parents)
+    return buildPathToNode(target, parents)
 }
 
-private fun <T> Map<T, Double>.minCostNode(explored: Collection<T>): T? {
-    val costs = this
-
-    var minCostNode: T? = null
-    var minCost = INFINITY
-    for ((node, cost) in costs) {
-        if (node !in explored && cost < minCost) {
-            minCostNode = node
-            minCost = cost
-        }
-    }
-    return minCostNode
-}
+private fun <T> Map<T, Double>.findMinCostNode(explored: Collection<T>): T? = 
+    // turning costs to sequence to improve performance of further operations.
+    asSequence()
+        // ignoring already explored nodes.
+        .filter { (node, _) -> node !in explored } 
+        // finding the min cost node.
+        .minBy { (_, cost) -> cost} 
+        // returning node object or `null` if the node was not found.
+        ?.key 
 
 /**
  * Build path from root to target node.
  */
-private fun <T> pathToNode(target: T, parents: Map<T, T>): List<T> {
-    if (target !in parents) return emptyList()
+private fun <T> buildPathToNode(target: T, parents: Map<T, T>): List<T> {
+    if (target !in parents) error("Invalid arguments provided.")
 
     val path = mutableListOf<T>()
     var node: T? = target

src/kotlin/sequential/graph/dijkstra/Dijkstra.kt

@@ -0,0 +1,9 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_binary")
+
+swift_binary(
+    name = "dijkstra",
+    srcs = [
+        "Dijkstra.swift",
+        "main.swift",
+    ],
+)

src/swift/sequential/graph/dijkstra/BUILD

@@ -0,0 +1,60 @@
+typealias Graph<T: Hashable> = [T: [T: Double]]
+
+
+let infinity = Double.infinity
+
+
+func dijkstra<T>(in graph: Graph<T>, withRoot root: T, findPathTo target: T) -> [T]? {
+    var costs = graph[root] ?? [:]
+    var explored = Set<T>()
+    var parents = graph[root]?.mapValues { cost in root } ?? [:]
+    
+    while let node = findMinCostNode(from: costs, except: explored) {
+        explored.insert(node)
+        let nodeCost = costs[node]!
+        
+        guard let successors = graph[node] else { continue }
+
+        for (succ, edgeWeight) in successors {
+            if nodeCost + edgeWeight < costs[succ] ?? infinity {
+                costs[succ] = nodeCost + edgeWeight
+                parents[succ] = node
+            }
+        }
+    }
+    
+    return buildPathTo(target, with: parents)
+}
+
+private func findMinCostNode<T>(from costs: [T: Double], except explored: Set<T>) -> T? {
+    return costs
+        .filter { node, cost in !explored.contains(node) }
+        .min { a, b in a.value < b.value}?
+        .key
+}
+
+private func buildPathTo<T>(_ target: T, with parents: [T: T]) -> [T]? {
+    guard parents[target] != nil else { return nil }
+    
+    var path = [T]()
+    var node: T? = target
+    while node != nil {
+        path.append(node!)
+        node = parents[node!]
+    }
+    return path.reversed()
+}
+
+
+func mainDijkstra() {
+    let graph: Graph<String> = [
+        "Start": ["A": 5],
+        "A": ["B": 7, "C": 4],
+        "B": ["Finish": 4],
+        "C": ["Finish": 3]
+    ]
+
+    print(
+        dijkstra(in: graph, withRoot: "Start", findPathTo: "Finish") ?? "Path not found!"
+    )
+}

src/swift/sequential/graph/dijkstra/Dijkstra.swift

@@ -0,0 +1 @@
+mainDijkstra()