Minimum Falling Path Sum - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Choose starting position

You can start skiing from any position in the top row

Follow movement rules

From each position, you can only move to three adjacent positions below

Build optimal subpaths

For each position, calculate the minimum cost to reach it from any valid previous position

Find global minimum

The answer is the minimum value among all possible ending positions

Key Takeaway

🎯 Key Insight: Use dynamic programming to build the solution incrementally - each position only needs to consider the three positions directly above it, leading to an efficient O(n²) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

⚠ Quadratic Growth

Space Complexity

O(1)

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

✓ Linear Space

Constraints

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

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

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(3^n)	O(n)	Try all possible paths from each starting position using recursion
Dynamic Programming (Optimal)	O(n²)	O(1)	Build solution bottom-up using dynamic programming for O(n²) time

Recursive Brute Force — Algorithm Steps

For each column in the first row, start a recursive exploration
At each position (row, col), try moving to (row+1, col-1), (row+1, col), and (row+1, col+1)
Handle boundary conditions for leftmost and rightmost columns
Return the minimum sum among all possible paths
Use memoization to avoid recalculating the same subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from each position in first row

Begin recursive exploration from each column in the first row

Explore three directions

From each position, try moving diagonally left, straight down, and diagonally right

Memoize results

Cache results to avoid recalculating the same subproblems

Code -

solution.c — C

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

#define MAX_N 100

int memo[MAX_N][MAX_N];
int matrix[MAX_N][MAX_N];
int n;

int min3(int a, int b, int c) {
    int min_ab = (a < b) ? a : b;
    return (min_ab < c) ? min_ab : c;
}

int dfs(int row, int col) {
    if (row == n) return 0;
    if (col < 0 || col >= n) return INT_MAX;
    if (memo[row][col] != INT_MAX) return memo[row][col];
    
    int result = matrix[row][col] + min3(
        dfs(row + 1, col - 1),
        dfs(row + 1, col),
        dfs(row + 1, col + 1)
    );
    memo[row][col] = result;
    return result;
}

int minFallingPathSum() {
    // Initialize memo
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            memo[i][j] = INT_MAX;
        }
    }
    
    int result = INT_MAX;
    for (int col = 0; col < n; col++) {
        int sum = dfs(0, col);
        if (sum < result) result = sum;
    }
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

Without memoization, each position explores 3 possibilities, leading to 3^n total combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is at most n levels deep

⚡ Linearithmic Space

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler