implemented knapsack and some explanations

Author: JakubSchwenkbeck

src/main/scala/algorithms/dynamic/Chessboard.scala

@@ -1,5 +1,18 @@
 package algorithms.dynamic
 
+/// Compute the number of valid paths for a king from (1,1) to (n,n) on an n×n chessboard
+///
+/// The king starts in the bottom-left corner (1,1) and must reach the top-right corner (n,n).
+/// A valid move must always bring the king closer to (n,n). The possible moves are:
+///   - Right: (x, y) → (x + 1, y)
+///   - Up: (x, y) → (x, y + 1)
+///   - Diagonal: (x, y) → (x + 1, y + 1)
+///
+/// We use **dynamic programming** to calculate the number of paths to each cell (x, y).
+/// The recurrence relation is:
+///   num(x, y) = num(x-1, y) + num(x, y-1) + num(x-1, y-1)
+///
+/// Time Complexity: O(n²) – We compute each cell once.
 def numberOfValidMoves(n: Int): (Int, Array[Array[Int]]) = {
   val num: Array[Array[Int]] = Array.fill(n, n)(0)
 
@@ -19,10 +32,11 @@ def numberOfValidMoves(n: Int): (Int, Array[Array[Int]]) = {
 @main
 def MainNumberOfValidMoves(): Unit = {
   val n: Int = 5
-  var (num, mat) = numberOfValidMoves(n)
+  val (num, mat) = numberOfValidMoves(n)
   println(s"Number of moves for $n is : $num")
+  // Print DP matrix for visualization
   mat.foreach { row =>
-    row foreach print; println
+    println(row.mkString("          "))
   }
 
 }

src/main/scala/algorithms/dynamic/Fibonacci.scala

@@ -1,7 +1,16 @@
 package algorithms.dynamic
 
-// top down :
-
+// Top-Down Recursive Fibonacci with Memoization
+/// This function calculates the nth Fibonacci number using recursion and memoization.
+/// It stores computed Fibonacci numbers in an array `A` to avoid redundant calculations (memorization).
+/// Base cases are handled directly: fib(0) = 1, fib(1) = 1.
+/// For other cases, it recursively computes the Fibonacci number and stores it in `A` for reuse.
+///
+/// Example:
+/// val (fib5, _) = recFibonacci(5)
+/// println(fib5) // 5
+///
+/// Time complexity: O(n) due to memoization (avoids recomputation).
 def recFibonacci(n: Int): (Int, Array[Int]) = {
   val A: Array[Int] = Array.fill(n + 1)(0)
   def recHelper(c: Int): Int = {
@@ -16,8 +25,16 @@ def recFibonacci(n: Int): (Int, Array[Int]) = {
   (recHelper(n), A)
 }
 
-// bottom up
-
+// Bottom-Up Dynamic Programming Fibonacci
+/// This function calculates the nth Fibonacci number using bottom-up dynamic programming.
+/// It iteratively computes Fibonacci numbers starting from the base cases and stores them in an array `A`.
+/// The result for each Fibonacci number is directly built up, avoiding recursion.
+///
+/// Example:
+/// val (fib5, _) = DPFibonacci(5)
+/// println(fib5) // 5
+///
+/// Time complexity: O(n) due to the iterative approach (no recursion).
 def DPFibonacci(n: Int): (Int, Array[Int]) = {
   val A: Array[Int] = Array.fill(n + 1)(0)
   A(0) = 1

src/main/scala/algorithms/dynamic/Knapsack.scala

@@ -0,0 +1,47 @@
+package algorithms.dynamic
+
+// Knapsack Problem (Bottom-Up Dynamic Programming):
+// Given a budget and arrays for item prices and values, find the maximum value
+// of items that can be selected without exceeding the budget.
+// The solution is built using dynamic programming, where we compute the
+// optimal value for each subproblem (considering each item and budget).
+//
+// Example:
+// Given prices: [2, 3, 4], values: [3, 4, 5], budget = 5
+// The optimal selection: item 1 (price 2, value 3) and item 2 (price 3, value 4)
+// for a total value of 7, without exceeding the budget of 5.
+
+def knapsack(budget: Int, prices: Array[Int], values: Array[Int]): Int = {
+  val n = prices.length
+  if (prices.length != values.length) throw new RuntimeException("Mismatching Arrays!")
+
+  // Create DP table (E) to store optimal values for subproblems
+  val E: Array[Array[Int]] = Array.ofDim[Int](budget + 1, n + 1)
+
+  // Initialize base case
+  for (j <- 0 to n) { E(0)(j) = 0 }
+  for (b <- 0 to budget) { E(b)(0) = 0 }
+
+  // Fill DP table using bottom-up
+  for (i <- 1 to n) { // Loop over items
+    for (b <- 1 to budget) { // Loop over possible budgets
+      if (prices(i - 1) <= b) { // If the current item can be included
+        E(b)(i) = Math.max(E(b)(i - 1), E(b - prices(i - 1))(i - 1) + values(i - 1))
+      } else {
+        E(b)(i) = E(b)(i - 1) // If the item can't be included, take the value from the previous row
+      }
+    }
+  }
+
+  // Return the maximum value with the given budget
+  E(budget)(n)
+}
+
+@main
+def knapSackMain(): Unit = {
+  val prices: Array[Int] = Array(2, 3, 4)
+  val values: Array[Int] = Array(3, 4, 5)
+  val budget = 5
+  val result = knapsack(budget, prices, values)
+  println(s"The knapsack solution for prices [2,3,4] and values [3,4,5] with budget 5 is $result")
+}

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

@@ -2,9 +2,9 @@ package datastructures.tree
 
 case class avlTree[T](
   key: T,
-  val left: Option[avlTree[T]] = None,
-  val right: Option[avlTree[T]] = None,
-  val parent: Option[avlTree[T]] = None
+  left: Option[avlTree[T]] = None,
+  right: Option[avlTree[T]] = None,
+  parent: Option[avlTree[T]] = None
 )
 
 def isSearchTree[T](avl: avlTree[T]): Boolean = {