implemented several Dynamic Programs

Author: JakubSchwenkbeck

src/main/scala/algorithms/dynamic/Decomposition.scala

@@ -0,0 +1,25 @@
+package algorithms.dynamic
+
+// Bottom-up dynamic programming approach
+def bottomUpDecomposition(prices: Array[Int], n: Int): Int = {
+  val dp = Array.fill(n + 1)(0) // dp[i] stores the max revenue for length i
+
+  for (j <- 1 to n) {
+    var maxVal = Int.MinValue
+    for (i <- 0 until j) {
+      maxVal = Math.max(maxVal, prices(i) + dp(j - i - 1))
+    }
+    dp(j) = maxVal
+  }
+
+  dp(n) // Return the max value for the full length
+}
+
+@main
+def DecMain(): Unit = {
+  val length = 4
+  val prices = Array(1, 5, 8, 9)
+  // Bottom-up approach
+  val bottomUpResult = bottomUpDecomposition(prices, length)
+  println(s"Bottom-up result: $bottomUpResult")
+}

src/main/scala/algorithms/dynamic/MaxNonAdjacentWeight.scala

@@ -0,0 +1,41 @@
+package algorithms.dynamic
+
+def maxNonAdjacentWeight(a: Array[Int]): (Int, List[Int]) = {
+  val n = a.length
+  if (n == 0) return (0, List())
+  if (n == 1) return (a(0), List(a(0)))
+
+  val dp = Array.fill(n)(0) // DP table for max weight
+  val sequence = Array.fill(n)(List[Int]()) // Store selected subsequence
+
+  // Base cases
+  dp(0) = a(0)
+  sequence(0) = List(a(0))
+
+  if (n > 1) {
+    dp(1) = Math.max(a(0), a(1))
+    sequence(1) = if (a(1) > a(0)) List(a(1)) else List(a(0))
+  }
+
+  // Fill DP table iteratively
+  for (i <- 2 until n) {
+    if (dp(i - 1) > dp(i - 2) + a(i)) {
+      dp(i) = dp(i - 1)
+      sequence(i) = sequence(i - 1) // Take the previous sequence
+    } else {
+      dp(i) = dp(i - 2) + a(i)
+      sequence(i) = sequence(i - 2) :+ a(i) // Append current element
+    }
+  }
+
+  (dp(n - 1), sequence(n - 1)) // Return max weight and sequence
+}
+
+@main
+def runMaxNonAdjacentWeight(): Unit = {
+  val a = Array(3, 2, 7, 10) // Example input
+  val (maxWeight, maxSequence) = maxNonAdjacentWeight(a)
+
+  println(s"Maximum weight: $maxWeight")
+  println(s"Selected sequence: $maxSequence")
+}

src/main/scala/algorithms/dynamic/OptimalMatrix.scala

@@ -1,33 +1,61 @@
 package algorithms.dynamic
 
-case class Matrix(n : Int, m : Int)
+case class Matrix(n: Int, m: Int)
 
-def optimalMatrixParentheses(lst : Array[Matrix]) : (Int, Array[Array[Int]]) = {
+def optimalMatrixParentheses(lst: Array[Matrix]): (Int, Array[Array[Int]]) = {
   val length = lst.length
-  val dp : Array[Array[Int]] = Array.fill(length,length)(0)
+  val dp: Array[Array[Int]] = Array.fill(length, length)(0)
+  val s: Array[Array[Int]] = Array.fill(length, length)(0)
 
-  for(i <- 1 until length ){
-    for(j <- 0 until length - i){
+  for (i <- 1 until length) {
+    for (j <- 0 until length - i) {
       val index = j + i
       dp(j)(index) = Int.MaxValue
-      for(k <- j  until index ){
-          val q = dp(j)(k) + dp(k+1)(index) + lst(j).n * lst(k).m * lst(index).m
-          if q < dp(j)(index) then dp(j)(index) = q
+      for (k <- j until index) {
+        val q = dp(j)(k) + dp(k + 1)(index) + lst(j).n * lst(k).m * lst(index).m
+        if (q < dp(j)(index)) {
+          dp(j)(index) = q
+          s(j)(index) = k
+        }
       }
-      //println(s"${dp(j)(index)}")
+      // println(s"${dp(j)(index)}")
     }
   }
 
-  (dp(0)(length -1 ) , dp)
+  def printSolution(s: Array[Array[Int]], i: Int, j: Int): Unit = {
+    if (i == j) {
+      print(s" A $i  ")
+    } else {
+      print(" ( ")
+      printSolution(s, i, s(i)(j))
+      printSolution(s, s(i)(j) + 1, j)
+      print(" ) ")
+    }
+  }
+
+  printSolution(s, 0, length - 1)
+  println("\n")
+
+  (dp(0)(length - 1), dp)
 }
 
 @main
-def MatrixMain() : Unit = {
-  val matrixList = Array(Matrix(3,5), Matrix(5,1), Matrix(1,4),Matrix(4,2))
-  val (num ,res) = optimalMatrixParentheses(matrixList)
+def MatrixMain(): Unit = {
+  val matrixList = Array(Matrix(5, 10), Matrix(10, 3), Matrix(3, 12), Matrix(12, 5), Matrix(5, 60), Matrix(60, 6))
+  val (num, res) = optimalMatrixParentheses(matrixList)
+  res.foreach { row =>
+    println(row.mkString("          "))
+  }
+
+  println(s"The minimal number of scalars is $num ")
+}
+
+def MatrixTest(): Unit = {
+  val matrixList = Array(Matrix(3, 5), Matrix(5, 1), Matrix(1, 4), Matrix(4, 2))
+  val (num, res) = optimalMatrixParentheses(matrixList)
   res.foreach { row =>
     println(row.mkString("          "))
   }
 
   println(s"The minimal number of scalars is $num ")
-}
+}

src/main/scala/datastructures/graph/graph.scala

@@ -27,4 +27,4 @@ class Graph[T](val isDirected: Boolean) {
   def getEdges: Iterable[Edge[T]] = edges
 
   def getNeighbors(vertex: T): Iterable[(T, Double)] = adjacencyList.getOrElse(vertex, Seq())
-}
+}

src/main/scala/datastructures/tree/AVLTree.scala

@@ -36,9 +36,9 @@ case class AVLTree[T](key: T, left: Option[AVLTree[T]] = None, right: Option[AVL
   }
 
   private def createUpdatedNode(
-                                 newLeft: Option[AVLTree[T]],
-                                 newRight: Option[AVLTree[T]]
-                               ): AVLTree[T] = {
+    newLeft: Option[AVLTree[T]],
+    newRight: Option[AVLTree[T]]
+  ): AVLTree[T] = {
     val newHeight = 1 + Math.max(
       newLeft.map(_.height).getOrElse(0),
       newRight.map(_.height).getOrElse(0)
@@ -67,13 +67,13 @@ case class AVLTree[T](key: T, left: Option[AVLTree[T]] = None, right: Option[AVL
 
   private def rightRotate()(implicit ord: Ordering[T]): AVLTree[T] = {
     val pivot = left.get
-    val newRight =  AVLTree(
+    val newRight = AVLTree(
       key = key,
       left = pivot.right,
       right = right,
       height = 1 + Math.max(pivot.getHeightOfRight, getHeightOfRight)
     )
-     AVLTree(
+    AVLTree(
       key = pivot.key,
       left = pivot.left,
       right = Some(newRight),
@@ -83,13 +83,13 @@ case class AVLTree[T](key: T, left: Option[AVLTree[T]] = None, right: Option[AVL
 
   private def leftRotate()(implicit ord: Ordering[T]): AVLTree[T] = {
     val pivot = right.get
-    val newLeft =  AVLTree(
+    val newLeft = AVLTree(
       key = key,
       left = left,
       right = pivot.left,
       height = 1 + Math.max(getHeightOfLeft, pivot.getHeightOfLeft)
     )
-     AVLTree(
+    AVLTree(
       key = pivot.key,
       left = Some(newLeft),
       right = pivot.right,

src/main/scala/datastructures/tree/BTree.scala

@@ -4,9 +4,9 @@ case class BTree[T: Ordering](keys: List[T] = List(), children: List[BTree[T]] =
 
   def search(value: T): Boolean = {
     keys match {
-      case Nil => false
+      case Nil                      => false
       case ks if ks.contains(value) => true
-      case ks if isLeaf => false
+      case ks if isLeaf             => false
       case ks =>
         val (left, right) = ks.span(implicitly[Ordering[T]].lt(_, value))
         children(left.length).search(value)
@@ -17,7 +17,7 @@ case class BTree[T: Ordering](keys: List[T] = List(), children: List[BTree[T]] =
     val (newRoot, maybeSplit) = insertInternal(newKey)
     maybeSplit match {
       case Some((median, rightNode)) => BTree(List(median), List(newRoot, rightNode), maxKeys)
-      case None => newRoot
+      case None                      => newRoot
     }
   }
 
@@ -34,7 +34,8 @@ case class BTree[T: Ordering](keys: List[T] = List(), children: List[BTree[T]] =
       maybeSplit match {
         case Some((median, rightNode)) =>
           val newKeys = (left :+ median) ++ right
-          val newChildrenWithSplit = (newChildren.take(left.length + 1) :+ rightNode) ++ newChildren.drop(left.length + 1)
+          val newChildrenWithSplit =
+            (newChildren.take(left.length + 1) :+ rightNode) ++ newChildren.drop(left.length + 1)
           splitIfNeeded(BTree(newKeys, newChildrenWithSplit, maxKeys))
         case None => (BTree(keys, newChildren, maxKeys), None)
       }