Minimum Path Sum - Practice Coding Problems

Minimum Path Sum - Problem

Minimum Path Sum

You are given an m x n grid filled with non-negative numbers. Your goal is to find a path from the top-left corner to the bottom-right corner that minimizes the sum of all numbers along the path.

Movement Rules:
• You can only move right or down at any point
• You cannot move diagonally, left, or up

Example:
For grid [[1,3,1],[1,5,1],[4,2,1]], the minimum path sum is 7 following the path: 1→3→1→1→1

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: grid = [[1,3,1],[1,5,1],[4,2,1]]

› Output: 7

💡 Note: The path 1→3→1→1→1 gives minimum sum of 7. Alternative paths like 1→1→5→1→1 would give sum of 9, which is larger.

example_2.py — 2x3 Grid

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

› Output: 12

💡 Note: The minimum path is 1→2→3→6, giving sum of 12. Going 1→4→5→6 would give 16.

example_3.py — Single Element

$ Input: grid = [[5]]

› Output: 5

💡 Note: Edge case: grid with only one element. The minimum (and only) path sum is the element itself.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
0 ≤ grid[i][j] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Start the Quest

Begin at entrance (top-left) with initial cost

Explore Options

At each room, can only move right or down

Calculate Costs

Each room's minimum cost = room cost + min(cost from top, cost from left)

Reach Treasure

Arrive at treasure room (bottom-right) with minimum total cost

Key Takeaway

🎯 Key Insight: Use dynamic programming to build up the solution - the minimum cost to reach any cell is its own cost plus the minimum of costs from its only two possible predecessors (top and left cells).

Asked in

a Amazon 42 G Google 38 ⊞ Microsoft 31 Apple 28 f Meta 25 B Bloomberg 19

The optimal approach uses dynamic programming with space optimization. We can solve this in O(m×n) time and O(n) space by using a 1D DP array that gets updated row by row. The key insight is that the minimum path sum to any cell depends only on the minimum path sums to the cell above and to the left.

Common Approaches

Approach	Time	Space	Notes
✓ Space-Optimized DP (1D Array)	O(m*n)	O(n)	Optimize space by using only one row for DP calculations
Dynamic Programming (2D Table)	O(m*n)	O(m*n)	Build a 2D table storing minimum path sums to each cell

Space-Optimized DP (1D Array) — Algorithm Steps

Create 1D DP array of size n (number of columns)
Initialize first element: dp[0] = grid[0][0]
Fill first row: dp[j] = dp[j-1] + grid[0][j]
For each subsequent row, update dp array left to right
dp[j] = grid[i][j] + min(dp[j], dp[j-1])
Return dp[n-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Row

Fill DP array with first row cumulative sums

Process Row 2

Update DP array using previous values

Process Row 3

Continue updating until final result

Final Result

Last element contains minimum path sum

Code -

solution.c — C

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

int minPathSum(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        return 0;
    }
    
    int m = gridSize;
    int n = gridColSize[0];
    
    // Use 1D DP array
    int* dp = (int*)malloc(n * sizeof(int));
    
    // Initialize first element
    dp[0] = grid[0][0];
    
    // Fill first row
    for (int j = 1; j < n; j++) {
        dp[j] = dp[j-1] + grid[0][j];
    }
    
    // Process remaining rows
    for (int i = 1; i < m; i++) {
        // Update first column element
        dp[0] += grid[i][0];
        
        // Update rest of the row
        for (int j = 1; j < n; j++) {
            int fromTop = dp[j];
            int fromLeft = dp[j-1];
            dp[j] = grid[i][j] + (fromTop < fromLeft ? fromTop : fromLeft);
        }
    }
    
    int result = dp[n-1];
    free(dp);
    
    return result;
}

int main() {
    int row1[] = {1, 3, 1};
    int row2[] = {1, 5, 1};
    int row3[] = {4, 2, 1};
    int* grid[] = {row1, row2, row3};
    int gridColSize[] = {3, 3, 3};
    
    printf("%d\n", minPathSum(grid, 3, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Still visit each cell exactly once

✓ Linear Growth

Space Complexity

O(n)

Only need one row of DP values at any time

⚡ Linearithmic Space

73.9K Views

High Frequency

~15 min Avg. Time

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

Space-Optimized DP (1D Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler