- MinimumFallingPathSum

Signed-off-by: Gopal S Akshintala <[email protected]>

Author: overfullstack

ds-algo/src/main/java/practice/dp/MinimumFallingPathSum.java

@@ -0,0 +1,33 @@
+package practice.dp;
+
+import java.util.Arrays;
+
+/* 26 Oct 2025 21:20 */
+
+/** [931. Minimum Falling Path Sum](https://leetcode.com/problems/minimum-falling-path-sum/) */
+public class MinimumFallingPathSum {
+	public int minFallingPathSum(int[][] matrix) {
+		var table = matrix[0].clone(); // ! Clone to avoid mutating input
+		for (var row = 1; row < matrix.length; row++) {
+			var prev = table[0]; // ! Store previous column value before overwriting
+			for (var col = 0; col < matrix[0].length; col++) {
+				var temp = table[col]; // ! Save current value before overwriting
+				if (col == 0) {
+					table[col] = matrix[row][col] + Math.min(table[col], table[col + 1]);
+				} else if (col == matrix[0].length - 1) {
+					table[col] = matrix[row][col] + Math.min(table[col], prev);
+				} else {
+					table[col] = matrix[row][col] + Math.min(table[col], Math.min(prev, table[col + 1]));
+				}
+				prev = temp; // ! Move to next column
+			}
+		}
+		return Arrays.stream(table).min().orElseThrow();
+	}
+
+	static void main() {
+		var l = new MinimumFallingPathSum();
+		System.out.println(l.minFallingPathSum(new int[][] {{2, 1, 3}, {6, 5, 4}, {7, 8, 9}})); // 13
+		System.out.println(l.minFallingPathSum(new int[][] {{-19, 57}, {-40, -5}})); // -59
+	}
+}

ds-algo/src/main/kotlin/leetcode/dp/MinimumPathSum.kt

@@ -1,28 +1,8 @@
 /* gakshintala created on 12/29/19 */
 package leetcode.dp
 
-/** https://leetcode.com/problems/minimum-path-sum/ */
-fun minPathSumRecursive(
-  grid: Array<IntArray>,
-  row: Int = grid.lastIndex,
-  col: Int = grid[0].lastIndex,
-  cache: MutableMap<Pair<Int, Int>, Int> = mutableMapOf(),
-): Int {
-  cache[row to col]?.let {
-    return it
-  }
-  val result =
-    when {
-      row < 0 || col < 0 -> Int.MAX_VALUE
-      row == 0 && col == 0 -> grid[0][0]
-      else ->
-        grid[row][col] +
-          minOf(minPathSumRecursive(grid, row - 1, col), minPathSumRecursive(grid, row, col - 1))
-    }
-  return cache.merge(row to col, result, ::maxOf)!!
-}
-
-fun minPathSumDp(grid: Array<IntArray>): Int {
+/** [64. Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum/) */
+fun minPathSumBottomUp(grid: Array<IntArray>): Int {
   if (grid.isEmpty()) {
     return 0
   }
@@ -44,3 +24,23 @@ fun minPathSumDp(grid: Array<IntArray>): Int {
   }
   return table[rows][cols]
 }
+
+fun minPathSumTopDown(
+  grid: Array<IntArray>,
+  row: Int = grid.lastIndex,
+  col: Int = grid[0].lastIndex,
+  memo: MutableMap<Pair<Int, Int>, Int> = mutableMapOf(),
+): Int {
+  memo[row to col]?.let {
+    return it
+  }
+  val result =
+    when {
+      row < 0 || col < 0 -> Int.MAX_VALUE
+      row == 0 && col == 0 -> grid[0][0]
+      else ->
+        grid[row][col] +
+          minOf(minPathSumTopDown(grid, row - 1, col), minPathSumTopDown(grid, row, col - 1))
+    }
+  return memo.merge(row to col, result, ::maxOf)!!
+}

ds-algo/src/main/kotlin/leetcode/dp/Triangle.kt

@@ -1,11 +1,13 @@
 package leetcode.dp
 
-/** https://leetcode.com/problems/triangle/ Find min path from bottom to top in a triangle. */
+/** [120. Triangle](https://leetcode.com/problems/triangle/) */
 fun minimumTotal(triangle: List<List<Int>>): Int {
-  val table = IntArray(triangle.size + 1)
-
-  for (row in triangle.lastIndex downTo 0) {
+  val table = triangle.last().toIntArray()
+  // ! Calculating from triangle bottom to top.
+  // ! It can be solved from top to bottom also, but need to tackle edge cases 0th and last col
+  for (row in triangle.lastIndex - 1 downTo 0) {
     for (col in 0..row) {
+      // ! Climb from min of prev `col` or `col + 1`, add current cost
       table[col] = minOf(table[col], table[col + 1]) + triangle[row][col]
     }
   }

ds-algo/src/main/kotlin/leetcode/dp/UniquePaths.kt

@@ -3,7 +3,6 @@ package leetcode.dp
 
 fun uniquePaths1d(m: Int, n: Int): Int {
   val table = IntArray(n) { 1 }
-
   repeat(m) {
     for (col in 1 until n) {
       table[col] += table[col - 1]

ds-algo/src/main/kotlin/leetcode/dp/UniquePathsWithObstacles.kt renamed to ds-algo/src/main/kotlin/leetcode/dp/UniquePaths2.kt

@@ -4,7 +4,7 @@ package leetcode.dp
 /** [63. Unique Paths II](https://leetcode.com/problems/unique-paths-ii/) */
 fun uniquePathsWithObstacles1d(obstacleGrid: Array<IntArray>): Int {
   val dp = IntArray(obstacleGrid.first().size)
-  dp[0] = 1
+  dp[0] = if (obstacleGrid[0][0] != 1) 1 else return 0
   for (row in obstacleGrid.indices) {
     for (col in obstacleGrid.first().indices) {
       // ! `table[row - 1][col]` is just borrowing from same col data from previous row.
@@ -30,7 +30,6 @@ fun uniquePathsWithObstacles2d(obstacleGrid: Array<IntArray>): Int {
   for (col in 1 until cols) {
     table[0][col] = if (obstacleGrid[0][col] == 1) 0 else table[0][col - 1]
   }
-
   for (row in 1 until rows) {
     for (col in 1 until cols) {
       if (obstacleGrid[row][col] != 1) {

ds-algo/src/test/kotlin/leetcode/dp/MinimumPathSumTest.kt

@@ -6,13 +6,14 @@ import io.kotest.matchers.shouldBe
 class MinimumPathSumTest :
   StringSpec({
     "minPathSumRecursive" {
-      minPathSumRecursive(
+      minPathSumTopDown(
         arrayOf(intArrayOf(1, 3, 1), intArrayOf(1, 5, 1), intArrayOf(4, 2, 1))
       ) shouldBe 7
     }
 
     "minPathSumDp" {
-      minPathSumDp(arrayOf(intArrayOf(1, 3, 1), intArrayOf(1, 5, 1), intArrayOf(4, 2, 1))) shouldBe
-        7
+      minPathSumBottomUp(
+        arrayOf(intArrayOf(1, 3, 1), intArrayOf(1, 5, 1), intArrayOf(4, 2, 1))
+      ) shouldBe 7
     }
   })