implemented DAGSSSP based on TopoSort

Author: JakubSchwenkbeck

src/main/scala/algorithms/graph/DagSSSP.scala

@@ -0,0 +1,30 @@
+package algorithms.graph
+
+import datastructures.graph.Graph
+import algorithms.graph.topologicalSort
+
+/// Single Source Shortest Paths (SSSP) in a Directed Acyclic Graph (DAG)
+/// Uses topological sorting and edge relaxation for shortest path calculation
+/// Returns a map of distances from the start vertex to all other vertices
+
+/// The algorithm runs in O(V + E) time complexity
+def DAGSingleSourceShortestPaths[T](graph: Graph[T], s: T): (Map[T, Double], Map[T, T]) = {
+  val maybeSortedList = topologicalSort(graph)
+  val sortedList = maybeSortedList.getOrElse(List.empty[T])
+
+  var dist: Map[T, Double] = sortedList.map(v => v -> Double.PositiveInfinity).toMap
+  var pred: Map[T, T] = Map()
+
+  dist = dist.updated(s, 0)
+
+  for (v <- sortedList) {
+    for ((u, weight) <- graph.getNeighbors(v)) {
+      if (dist(v) != Double.PositiveInfinity && dist(u) > dist(v) + weight) {
+        dist = dist.updated(u, dist(v) + weight)
+        pred = pred.updated(u, v)
+      }
+    }
+  }
+
+  (dist, pred)
+}

src/main/scala/algorithms/graph/TopoSort.scala

@@ -3,40 +3,42 @@ package algorithms.graph
 import datastructures.graph._
 import scala.collection.mutable
 
-//Kahns Algorithm
-def topologicalSort[T](graph : Graph[T]) : Option[List[T]] =  {
+/// Topological Sort of a Directed Acyclic Graph (DAG)
+/// Implements Kahn’s Algorithm (BFS-based)
+/// Returns an ordering of vertices such that for every directed edge (u, v), u appears before v.
+/// Detects cycles: If a cycle exists, returns None.
 
+/// Topological Sort runs in O(V + E)
+def topologicalSort[T](graph: Graph[T]): Option[List[T]] = {
   val inDegree = mutable.Map[T, Int]().withDefaultValue(0)
 
-    for ((src, neighbors) <- graph.adjacencyList) {
-      for ((dest, _) <- neighbors) {
-        inDegree.update(dest, inDegree(dest) + 1)
-      }
+  for ((src, neighbors) <- graph.adjacencyList) {
+    for ((dest, _) <- neighbors) {
+      inDegree.update(dest, inDegree(dest) + 1)
     }
+  }
 
-    //  Initialize queue with nodes having in-degree 0
-    val queue = mutable.Queue[T]()
-    for (vertex <- graph.adjacencyList.keys if inDegree(vertex) == 0) {
-      queue.enqueue(vertex)
-    }
+  //  Initialize queue with nodes having in-degree 0
+  val queue = mutable.Queue[T]()
+  for (vertex <- graph.adjacencyList.keys if inDegree(vertex) == 0) {
+    queue.enqueue(vertex)
+  }
 
-    val sortedList = mutable.ListBuffer[T]()
+  val sortedList = mutable.ListBuffer[T]()
 
-    //  Process queue
-    while (queue.nonEmpty) {
-      val vertex = queue.dequeue()
-      sortedList.append(vertex)
+  //  Process queue
+  while (queue.nonEmpty) {
+    val vertex = queue.dequeue()
+    sortedList.append(vertex)
 
-      for ((neighbor, _) <- graph.adjacencyList(vertex)) {
-        inDegree.update(neighbor, inDegree(neighbor) - 1)
-        if (inDegree(neighbor) == 0) {
-          queue.enqueue(neighbor)
-        }
+    for ((neighbor, _) <- graph.adjacencyList(vertex)) {
+      inDegree.update(neighbor, inDegree(neighbor) - 1)
+      if (inDegree(neighbor) == 0) {
+        queue.enqueue(neighbor)
       }
     }
+  }
 
-    //  Cycle check
-    if (sortedList.size == graph.adjacencyList.size) Some(sortedList.toList) else None
+  //  Cycle check
+  if (sortedList.size == graph.adjacencyList.size) Some(sortedList.toList) else None
 }
-
-

src/test/scala/algorithms/graph/DAGSingleSourceShortestPathsTest.scala

@@ -0,0 +1,35 @@
+package algorithms.graph
+
+import datastructures.graph._
+import munit.FunSuite
+
+class DAGSingleSourceShortestPathsTest extends FunSuite {
+
+  test("DAG SSSP should return correct shortest paths and predecessors") {
+    val graph = new Graph[Char](true) // Directed Graph
+    graph.addEdge('A', 'B', 1)
+    graph.addEdge('A', 'C', 4)
+    graph.addEdge('B', 'C', 2)
+    graph.addEdge('B', 'D', 5)
+    graph.addEdge('C', 'D', 1)
+
+    val (distances, predecessors) = DAGSingleSourceShortestPaths(graph, 'A')
+
+    // Expected distances from 'A'
+    val expectedDistances = Map('A' -> 0.0, 'B' -> 1.0, 'C' -> 3.0, 'D' -> 4.0)
+    assertEquals(distances, expectedDistances)
+
+    // Expected predecessors
+    val expectedPredecessors = Map('B' -> 'A', 'C' -> 'B', 'D' -> 'C')
+    assertEquals(predecessors, expectedPredecessors)
+  }
+
+  test("DAG SSSP should work with a single-node graph") {
+    val graph = new Graph[Char](true)
+    graph.addVertex('A')
+
+    val (distances, predecessors) = DAGSingleSourceShortestPaths(graph, 'A')
+
+    assertEquals(distances, Map('A' -> 0.0))
+  }
+}

src/test/scala/algorithms/graph/TopologicalSortTest.scala

@@ -0,0 +1,39 @@
+package algorithms.graph
+
+import datastructures.graph._
+import munit.FunSuite
+
+class TopologicalSortTest extends FunSuite {
+
+  test("Topological sort returns valid order for DAG") {
+    val graph = new Graph[Char](true) // Directed Graph
+    graph.addEdge('A', 'B')
+    graph.addEdge('A', 'C')
+    graph.addEdge('B', 'D')
+    graph.addEdge('C', 'D')
+    graph.addEdge('D', 'E')
+
+    val result = topologicalSort(graph)
+
+    assert(result.isDefined, "Topological sort should return Some(List) for a DAG")
+
+    val sortedOrder = result.get
+    val indexMap = sortedOrder.zipWithIndex.toMap
+
+    // Ensure each edge (u, v) respects u before v
+    for (Edge(src, dest, _) <- graph.getEdges) {
+      assert(indexMap(src) < indexMap(dest), s"Edge $src -> $dest violated topological order")
+    }
+  }
+
+  test("Topological sort returns None for cyclic graph") {
+    val cyclicGraph = new Graph[Char](true) // Directed Graph
+    cyclicGraph.addEdge('A', 'B')
+    cyclicGraph.addEdge('B', 'C')
+    cyclicGraph.addEdge('C', 'A') // Creates a cycle
+
+    val result = topologicalSort(cyclicGraph)
+
+    assert(result.isEmpty, "Topological sort should return None for cyclic graphs")
+  }
+}