minor dijkstra refactoring

Author: Morfly

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

@@ -12,11 +12,12 @@
 
 class Dijkstra {
 
+    // Infinity as a default vertex cost value.
     private static final double INFINITY = Double.POSITIVE_INFINITY;
 
 
     public static <T> List<T> dijkstra(Map<T, Map<T, Double>> graph, T root, T target) {
-        if (!graph.containsKey(root)) throw new IllegalArgumentException("Invalid root.");
+        if (!graph.containsKey(root)) throw new IllegalArgumentException("Invalid root vertex.");
 
         var costs = new HashMap<>(graph.get(root));
         var explored = new HashSet<T>();
@@ -55,7 +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 target.");
+        if (!parents.containsKey(target)) throw new IllegalArgumentException("Invalid target vertex.");
 
         var path = new LinkedList<T>();
         T node = target;

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

@@ -1,15 +1,15 @@
 package sequential.graph.dijkstra
 
 
-/**
- * Weighted graph representation using hash table.
- * @param T graph value type.
- */
-private typealias Graph<T> = Map<T, Map<T, Double>>
+// Weighted graph map representation where `key` = source vertex, `value` = destination vertices with edge weights.
+private typealias Graph<T> = Map<T, Edges<T>>
+// Weighted edges to destination vertices.
+private typealias Edges<T> = Map<T, Weight>
+// Edge weight.
+private typealias Weight = Double
 
-/**
- * Infinity value which is used as graph edge weight.
- */
+
+// Infinity as a default vertex cost value.
 private val INFINITY = Double.POSITIVE_INFINITY
 
 
@@ -18,7 +18,7 @@ private val INFINITY = Double.POSITIVE_INFINITY
  */
 fun <T: Any> Graph<T>.dijkstra(root: T, target: T): Collection<T> {
     val graph = this
-    require(root in graph) { "Invalid root." }
+    require(root in graph) { "Invalid root vertex." }
 
     val costs = graph[root]!!.toMutableMap()
     val explored = mutableSetOf<T>()
@@ -43,7 +43,7 @@ fun <T: Any> Graph<T>.dijkstra(root: T, target: T): Collection<T> {
 }
 
 private fun <T> Map<T, Double>.findMinCostNode(explored: Collection<T>): T? = 
-    // turning costs to sequence to improve performance of further operations.
+    // turning costs to sequence for faster further operations.
     asSequence()
         // ignoring already explored nodes.
         .filter { (node, _) -> node !in explored } 
@@ -56,7 +56,7 @@ private fun <T> Map<T, Double>.findMinCostNode(explored: Collection<T>): T? =
  * Build path from root to target node.
  */
 private fun <T: Any> buildPathToNode(target: T, parents: Map<T, T>): List<T> {
-    require(target in parents) { "Invalid target."}
+    require(target in parents) { "Invalid target vertex."}
 
     return generateSequence(target) { node -> parents[node] }
         .toList()
@@ -65,7 +65,7 @@ private fun <T: Any> buildPathToNode(target: T, parents: Map<T, T>): List<T> {
 
 
 fun main() {
-    val graph: Graph<String> = mapOf(
+    val graph = 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),

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

@@ -9,26 +9,28 @@ def dijkstra(graph, root, target):
     explored = set()
     parents = {node: root for node in graph[root]}
 
-    node = find_min_cost_node(costs, explored)
+    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) or infinity):
-                costs[succ] = node_cost + edge_cost
+        for (succ, edge_weight) in successors.items():
+            if node_cost + edge_weight < (costs.get(succ) or infinity):
+                costs[succ] = node_cost + edge_weight
                 parents[succ] = node
 
-        node = find_min_cost_node(costs, explored)
+        node = _find_min_cost_node(costs, explored)
 
-    return build_path_to_node(target, parents)
+    return _build_path_to_node(target, parents)
 
-def find_min_cost_node(costs, explored):
+def _find_min_cost_node(costs, explored):
+    # ignoring already explored nodes.
     costs = {node: cost for (node, cost) in costs.items() if node not in explored}
+    # returning the min cost node or `None` if not found. `costs.get` corresponds to node cost.
     return min(costs, key=costs.get, default=None)
 
-def build_path_to_node(target, parents):
+def _build_path_to_node(target, parents):
     if target not in parents:
         return None
 

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

@@ -1,8 +1,12 @@
-/// Weighted graph representation using dictionary.
-typealias Graph<T: Hashable> = [T: [T: Double]]
+/// Weighted graph dictionary representation where `key` = source vertex, `value` = destination vertices  edge weights.
+typealias Graph<T: Hashable> = [T: Edges<T>]
+/// Weighted edges to destination vertices.
+typealias Edges<T: Hashable> = [T: Weight]
+/// Edge weight.
+typealias Weight = Double
 
 
-/// Infinity as a default node cost value.
+/// Infinity as a default vertex cost value.
 let infinity = Double.infinity
 
 
@@ -71,11 +75,9 @@ private func findMinCostNode<T>(in costs: [T: Double], except explored: Set<T>)
 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!]
+    var path = [target]
+    while let node = parents[path.last!] {
+        path.append(node)
     }
     return path.reversed()
 }