Minimum Falling Path Sum

Minimum Falling Path Sum - Problem

Imagine you're a ball rolling down a triangular mountain, and at each level you can only move to adjacent positions in the row below. Your goal is to find the path that gives you the minimum total cost as you fall from the top to the bottom.

Given an n × n matrix of integers, return the minimum sum of any falling path through the matrix. A falling path:

Starts at any element in the first row
At each step, moves to an adjacent element in the next row
From position (row, col), you can move to (row + 1, col - 1), (row + 1, col), or (row + 1, col + 1)

Example: In matrix [[2,1,3],[6,5,4],[7,8,9]], the path 1 → 5 → 7 gives sum = 13, which is minimal.

Input & Output

example_1.py — Standard Case

$ Input: matrix = [[2,1,3],[6,5,4],[7,8,9]]

› Output: 13

💡 Note: The optimal path is 1→5→7 with sum = 1+5+7 = 13. Other paths like 2→6→7 (sum=15) or 3→4→9 (sum=16) have larger sums.

example_2.py — Negative Numbers

$ Input: matrix = [[-19,57],[-40,-5]]

› Output: -59

💡 Note: The optimal path is -19→(-40) with sum = -19+(-40) = -59. The alternative path -19→(-5) gives sum = -24, which is larger.

example_3.py — Single Element

$ Input: matrix = [[100]]

› Output: 100

💡 Note: With only one element, there's only one possible path, so the minimum sum is 100.

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 100
-100 ≤ matrix[i][j] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses dynamic programming with O(n²) time and O(1) space complexity. We build the minimum path sum row by row, where each cell stores the minimum sum needed to reach that position. For each position, we consider the three possible previous positions and take the minimum.

Common Approaches

✓ Dynamic Programming (Optimal)

⏱️ Time: O(n²) Space: O(1)

Use dynamic programming to build the minimum path sum for each position row by row. For each cell, calculate the minimum sum by considering the three possible previous positions in the row above. We can optimize space by modifying the matrix in-place or using only two rows.

Recursive Brute Force

⏱️ Time: O(3^n) Space: O(n)

For each starting position in the first row, recursively explore all possible paths to the bottom. At each position, try moving to all three possible positions in the next row and return the minimum sum path.

Dynamic Programming (Optimal) — Algorithm Steps

Start from the second row (first row is already the base case)
For each position (i, j), calculate minimum sum from three possible previous positions
Handle boundary conditions for leftmost and rightmost columns
Update each cell with matrix[i][j] + min(possible previous positions)
Return the minimum value in the last row

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize first row

The first row values remain unchanged as starting points

Process each subsequent row

For each cell, add the minimum of three possible previous positions

Find minimum in last row

The answer is the minimum value in the final row

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define MAX_N 100

int minFallingPathSum(int matrix[MAX_N][MAX_N], int n) {
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int minPrev = matrix[i-1][j];
            
            if (j > 0 && matrix[i-1][j-1] < minPrev) {
                minPrev = matrix[i-1][j-1];
            }
            
            if (j < n-1 && matrix[i-1][j+1] < minPrev) {
                minPrev = matrix[i-1][j+1];
            }
            
            matrix[i][j] += minPrev;
        }
    }
    
    int result = matrix[n-1][0];
    for (int j = 1; j < n; j++) {
        if (matrix[n-1][j] < result) {
            result = matrix[n-1][j];
        }
    }
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We visit each cell exactly once, and there are n² cells in the matrix

✓ Linear Growth

Space Complexity

O(1)

We can solve in-place by modifying the input matrix, or use O(n) space for one additional row

⚡ Linearithmic Space

125.0K Views

High Frequency

~15 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler