Minimum Falling Path Sum II

Minimum Falling Path Sum II - Problem

Imagine you're a treasure hunter navigating through a dangerous multi-level dungeon! 🏴‍☠️ You have an n x n grid where each cell contains a treasure value (which could be negative - representing traps!). Your goal is to collect treasures by moving from the top row to the bottom row, picking exactly one treasure from each level. Here's the catch: you cannot pick treasures directly below each other - you must shift to a different column in each move. This is called a "falling path with non-zero shifts." Your mission: Find the path that gives you the minimum sum of treasures collected. Example: If you have a 3x3 grid:
[[1,2,3], [4,5,6], [7,8,9]]
One valid path could be: pick 1 (row 0, col 0) → pick 5 (row 1, col 1) → pick 9 (row 2, col 2), giving sum = 15.

Input & Output

example_1.py — Basic 3x3 Grid

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

› Output: 13

💡 Note: The minimum falling path is [1,5,9] → but this violates the non-zero shift constraint. Valid paths include [1,4,8]=13, [1,6,7]=14, [2,4,9]=15, [2,6,7]=15, [3,4,8]=15, [3,5,7]=15. The minimum is 13.

example_2.py — Single Element

$ Input: grid = [[7]]

› Output: 7

💡 Note: With only one element, there's no choice but to take that element. No shifts are needed since there's only one row.

example_3.py — Negative Values

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

› Output: -15

💡 Note: Optimal paths include [-3,-5,-7] and [-1,-5,-9], both giving sum -15. The algorithm finds the minimum falling path sum of -15.

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 200
-99 ≤ grid[i][j] ≤ 99
Non-zero shifts required - cannot pick elements in same column from adjacent rows

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal solution uses dynamic programming with min/second min tracking. Key insight: for each cell, we only need the minimum value from the previous row that's in a different column. If our column matches the minimum's column, use the second minimum instead. This achieves O(n²) time and O(1) space complexity.

Common Approaches

✓ Brute Force (Recursive Exploration)

⏱️ Time: O(n^(n+1)) Space: O(n)

This approach explores every possible falling path by trying all valid moves from each position. For each cell in a row, we recursively explore all cells in the next row (except the one directly below) and take the minimum sum path.

Dynamic Programming (Bottom-Up)

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

This approach uses dynamic programming with tabulation. We create a DP table where dp[i][j] represents the minimum sum to reach cell (i,j). We fill the table row by row, and for each cell, we consider all valid previous positions (different columns in the previous row).

Optimized DP (Space Optimized)

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

The key insight is that we only need to know the minimum and second minimum values from the previous row to make optimal decisions. This reduces both time and space complexity significantly by avoiding the need to check all n positions for each cell.

Brute Force (Recursive Exploration) — Algorithm Steps

Start from each cell in the first row
For each cell, recursively explore all valid next positions (different columns)
Calculate the sum for each complete path
Return the minimum sum among all paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin from each cell in the first row

Explore Branches

Recursively try all valid next positions

Calculate Sums

Sum up path values for each complete route

Find Minimum

Return the path with minimum total sum

Code -

solution.c — C

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

static int grid[201][201];
static int n;

int dfs(int row, int col) {
    if (row == n - 1) {
        return grid[row][col];
    }
    
    int minSum = INT_MAX;
    for (int nextCol = 0; nextCol < n; nextCol++) {
        if (nextCol != col) {
            int sum = grid[row][col] + dfs(row + 1, nextCol);
            if (sum < minSum) {
                minSum = sum;
            }
        }
    }
    
    return minSum;
}

int minFallingPathSum() {
    if (n == 1) {
        return grid[0][0];
    }
    
    int result = INT_MAX;
    
    for (int col = 0; col < n; col++) {
        int sum = dfs(0, col);
        if (sum < result) {
            result = sum;
        }
    }
    
    return result;
}

void parseGrid(char* input) {
    int len = strlen(input);
    if (len <= 2) {
        n = 0;
        return;
    }
    
    n = 0;
    int row = 0, col = 0;
    int num = 0;
    int inNumber = 0;
    int negative = 0;
    
    for (int i = 1; i < len - 1; i++) {
        if (input[i] == '[') {
            col = 0;
            continue;
        } else if (input[i] == ']') {
            if (inNumber) {
                grid[row][col] = negative ? -num : num;
                col++;
                inNumber = 0;
                num = 0;
                negative = 0;
            }
            if (col > 0) {
                if (row == 0) n = col;
                row++;
            }
            continue;
        } else if (input[i] == ',') {
            if (inNumber) {
                grid[row][col] = negative ? -num : num;
                col++;
                inNumber = 0;
                num = 0;
                negative = 0;
            }
            continue;
        } else if (input[i] == '-') {
            negative = 1;
            inNumber = 1;
        } else if (input[i] >= '0' && input[i] <= '9') {
            num = num * 10 + (input[i] - '0');
            inNumber = 1;
        }
    }
    
    n = row;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    int len = strlen(input);
    if (len > 0 && input[len-1] == '\n') {
        input[len-1] = '\0';
    }
    
    parseGrid(input);
    printf("%d\n", minFallingPathSum());
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^(n+1))

For each of n rows, we explore up to (n-1) possibilities, leading to exponential growth

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth is n (number of rows)

✓ Linear Space

38.4K Views

Medium-High Frequency

~25 min Avg. Time

1.2K 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

Brute Force (Recursive Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler