Minimum Falling Path Sum II - Practice Coding Problems

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 = [[2,1,3],[6,5,4],[7,8,9]]

› Output: 13

💡 Note: Optimal path: [1,6,9] = 16? No, that's same column! Try [1,4,7] = 12? No, positions are [0,1], [2,2], [2,0] - invalid. Valid: [1,6,7]=14, [1,4,8]=13. Minimum is 13.

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

Understanding the Visualization

Track Best Options

For each level, identify the minimum and second minimum treasure values

Smart Path Choice

When moving to next level, choose the best available option (avoiding same column)

Accumulate Optimally

Build up the best path by always making locally optimal choices

Final Treasure Count

The minimum value in the last row gives us the optimal treasure sum

Key Takeaway

🎯 Key Insight: By tracking only the minimum and second minimum values from each row, we can make optimal decisions in constant time per cell, achieving the best possible time complexity of O(n²) while using minimal space.

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

Approach	Time	Space	Notes
✓ Brute Force (Recursive Exploration)	O(n^(n+1))	O(n)	Try every possible path combination using recursion
Optimized DP (Space Optimized)	O(n²)	O(1)	Track only first and second minimum from previous row for optimal solution
Dynamic Programming (Bottom-Up)	O(n³)	O(n²)	Build up optimal solutions row by row using tabulation

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>

int dfs(int** grid, int n, 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(grid, n, row + 1, nextCol);
            if (sum < minSum) {
                minSum = sum;
            }
        }
    }
    
    return minSum;
}

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

int main() {
    // Initialize a sample grid
    int n = 3;
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Sample data
    int data[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            grid[i][j] = data[i][j];
        }
    }
    
    printf("%d\n", minFallingPathSum(grid, n));
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    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

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is n (number of rows)

⚡ Linearithmic 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