improved dijkstra

Author: Morfly

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

@@ -12,14 +12,14 @@ 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());
+        if(!graph.containsKey(root)) throw new IllegalArgumentException("Invalid root.");
 
-        var costs = new HashMap<>(rootSuccessors);
+        var costs = new HashMap<>(graph.get(root));
         var explored = new HashSet<T>();
         var parents = new HashMap<T, T>();
-        for (var node : rootSuccessors.keySet())
+        for (var node : graph.get(root).keySet())
             parents.put(node, root);
 
         var node = findMinCostNode(costs, explored);
@@ -56,8 +56,7 @@ private static <T> T findMinCostNode(Map<T, Double> costs, Set<T> explored) {
     }
 
     private static <T> List<T> buildPathToNode(T target, Map<T, T> parents) {
-        if (!parents.containsKey(target))
-            throw new IllegalArgumentException("Invalid arguments provided.");
+        if (!parents.containsKey(target)) throw new IllegalArgumentException("Invalid target.");
 
         var path = new LinkedList<T>();
         T node = target;

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

@@ -18,10 +18,11 @@ private val INFINITY = Double.POSITIVE_INFINITY
  */
 fun <T> Graph<T>.dijkstra(root: T, target: T): Collection<T> {
     val graph = this
+    require(root in graph) { "Invalid root." }
 
-    val costs = graph[root].orEmpty().toMutableMap()
+    val costs = graph[root]!!.toMutableMap()
     val explored = mutableSetOf<T>()
-    val parents = graph[root].orEmpty().mapValues { root }.toMutableMap()
+    val parents = graph[root]!!.mapValues { root }.toMutableMap()
 
     var node = costs.findMinCostNode(explored)
     while (node != null) {
@@ -55,7 +56,7 @@ private fun <T> Map<T, Double>.findMinCostNode(explored: Collection<T>): T? =
  * Build path from root to target node.
  */
 private fun <T> buildPathToNode(target: T, parents: Map<T, T>): List<T> {
-    if (target !in parents) error("Invalid arguments provided.")
+    require(target in parents) { "Invalid target."}
 
     val path = mutableListOf<T>()
     var node: T? = target
@@ -68,14 +69,14 @@ private fun <T> buildPathToNode(target: T, parents: Map<T, T>): List<T> {
 
 
 fun main() {
-    val waypoints: Graph<String> = mapOf(
+    val graph: Graph<String> = mapOf(
         "Start" to mapOf("A" to 5.0),
         "A" to mapOf("B" to 7.0, "C" to 4.0),
         "B" to mapOf("Finish" to 4.0),
         "C" to mapOf("Finish" to 3.0)
     )
 
     println(
-        waypoints.dijkstra("Start", "Finish")
+        graph.dijkstra("Start", "Finish")
     )
 }

src/python/sequential/graph/dijkstra/BUILD

@@ -0,0 +1,5 @@
+py_binary(
+    name = "dijkstra",
+    main = "dijkstra.py",
+    srcs = glob(["*.py"]),
+)

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

@@ -0,0 +1,57 @@
+infinity = float("inf")
+
+
+def dijkstra(graph, root, target):
+    if root not in graph:
+        return None
+
+    costs = graph[root]
+    explored = set()
+    parents = {node: root for node in graph[root]}
+
+    node = find_min_cost_node(costs, explored)
+    while node:
+        explored.add(node)
+        node_cost = costs[node]
+
+        successors = graph.get(node, {})
+        for (succ, edge_cost) in successors.items():
+            if node_cost + edge_cost < costs.get(succ, infinity):
+                costs[succ] = node_cost + edge_cost
+                parents[succ] = node
+
+        node = find_min_cost_node(costs, explored)
+
+    return build_path_to_node(target, parents)
+
+
+def find_min_cost_node(costs, explored):
+    costs = {node: cost for (node, cost) in costs.items() if node not in explored}
+    return min(costs, key=costs.get, default=None)
+
+def build_path_to_node(target, parents):
+    if target not in parents:
+        return None
+
+    path = []
+    node = target
+    while node:
+        path.append(node)
+        node = parents.get(node)
+    return path[::-1]
+
+
+def main():
+    graph = {
+        "Start": {"A": 5},
+        "A": {"B": 7, "C": 4},
+        "B": {"Finish": 4},
+        "C": {"Finish": 3},
+    }
+
+    print(
+        dijkstra(graph, "Start", "Finish")
+    )
+
+if __name__ == "__main__":
+    main()

src/python/sequential/graph/dijkstra/dijkstra.py

@@ -1,15 +1,29 @@
+/// Weighted graph representation using dictionary.
 typealias Graph<T: Hashable> = [T: [T: Double]]
 
 
+/// Infinity as a default node cost value.
 let infinity = Double.infinity
 
 
+/**
+ Finds fastest path between specified nodes in the given graph.
+
+ - Parameters:
+    - graph: Given graph.
+    - root: Beginning of the path.
+    - target: End of the path.
+
+ - Returns: Array representing path to the `target` node starting from `root` or `nil` if invalid arguments provided.
+ */
 func dijkstra<T>(in graph: Graph<T>, withRoot root: T, findPathTo target: T) -> [T]? {
-    var costs = graph[root] ?? [:]
+    guard graph[root] != nil else { return nil }
+
+    var costs = graph[root]!
     var explored = Set<T>()
-    var parents = graph[root]?.mapValues { cost in root } ?? [:]
+    var parents = graph[root]!.mapValues { _ in root }
 
-    while let node = findMinCostNode(from: costs, except: explored) {
+    while let node = findMinCostNode(in: costs, except: explored) {
         explored.insert(node)
         let nodeCost = costs[node]!
 
@@ -26,13 +40,34 @@ func dijkstra<T>(in graph: Graph<T>, withRoot root: T, findPathTo target: T) ->
     return buildPathTo(target, with: parents)
 }
 
-private func findMinCostNode<T>(from costs: [T: Double], except explored: Set<T>) -> T? {
+/**
+ Finds the cheapest node at the given moment.
+ 
+ - Parameters:
+    - costs: Dictionary which contains costs of all nodes at the given moment.
+    - explored: Ignored nodes which are already explored.
+ 
+ - Returns: Min cost node at the given moment or `nil` if all nodes are already explored.
+ */
+private func findMinCostNode<T>(in costs: [T: Double], except explored: Set<T>) -> T? {
     return costs
+        // ignoring already explored nodes.
         .filter { node, cost in !explored.contains(node) }
-        .min { a, b in a.value < b.value}?
+        // finding the min cost node. `value` corresponds to node cost.
+        .min { cost1, cost2 in cost1.value < cost2.value}?
+        // returning node object or `nil` if the node was not found.
         .key
 }
 
+/**
+ Builds a path to the given node starting from root.
+ 
+ - Parameters:
+    - target: Given node which represends the end of the path.
+    - parents: Dictionary which contains parents of all graph nodes.
+ 
+ - Returns: Array representing path to the `target` node starting from `root` or `nil` if invalid arguments provided.
+ */
 private func buildPathTo<T>(_ target: T, with parents: [T: T]) -> [T]? {
     guard parents[target] != nil else { return nil }
 
@@ -47,11 +82,11 @@ private func buildPathTo<T>(_ target: T, with parents: [T: T]) -> [T]? {
 
 
 func mainDijkstra() {
-    let graph: Graph<String> = [
-        "Start": ["A": 5],
-        "A": ["B": 7, "C": 4],
-        "B": ["Finish": 4],
-        "C": ["Finish": 3]
+    let graph = [
+        "Start": ["A": 5.0],
+        "A": ["B": 7.0, "C": 4.0],
+        "B": ["Finish": 4.0],
+        "C": ["Finish": 3.0]
     ]
 
     print(