Minimum Path Cost in a Grid

Minimum Path Cost in a Grid - Problem

Problem: Find the Minimum Path Cost in a Grid

Imagine you're navigating through a special grid maze where you can only move downward from one row to the next, but you have the freedom to choose any column in the next row!

Given:
• An m x n integer matrix grid with distinct values from 0 to m * n - 1
• A moveCost array where moveCost[i][j] represents the cost of moving from a cell with value i to column j in the next row

Movement Rules:
• From cell (x, y), you can move to any cell (x+1, 0), (x+1, 1), ..., (x+1, n-1)
• You cannot move from the last row (it's your destination!)

Goal: Find the minimum total cost path from any cell in the first row to any cell in the last row. The total cost includes both the cell values you visit plus the movement costs between cells.

This is a classic dynamic programming problem that tests your ability to optimize multi-dimensional decision making!

Input & Output

example_1.py — Basic 3x3 Grid

$ Input: grid = [[5,3],[4,0],[2,1]], moveCost = [[9,8],[1,5],[10,12],[8,4],[1,3],[2,7]]

› Output: 8

💡 Note: The optimal path is (0,1) → (1,1) → (2,1). Cost = 3 + moveCost[3][1] + 0 + moveCost[0][1] + 1 = 3 + 4 + 0 + 8 + 1 = 16. Actually, let me recalculate: path (0,1) → (1,1) → (2,0): cost = 3 + moveCost[3][1] + 0 + moveCost[0][0] + 2 = 3 + 4 + 0 + 9 + 2 = 18. The minimum path is (0,0) → (1,1) → (2,0): cost = 5 + moveCost[5][1] + 0 + moveCost[0][0] + 2 = 5 + 7 + 0 + 9 + 2 = 23. Wait, let me verify all paths systematically...

example_2.py — Simple 2x2 Grid

$ Input: grid = [[5,1,2],[4,0,3]], moveCost = [[12,10,15],[20,23,8],[21,7,1],[8,1,13],[9,10,25],[5,3,2]]

› Output: 6

💡 Note: The optimal path is (0,1) → (1,1). Cost = 1 + moveCost[1][1] + 0 = 1 + 5 + 0 = 6.

example_3.py — Single Column Edge Case

$ Input: grid = [[1],[2],[3]], moveCost = [[2],[3],[1]]

› Output: 6

💡 Note: Only one possible path: (0,0) → (1,0) → (2,0). Cost = 1 + moveCost[1][0] + 2 + moveCost[2][0] + 3 = 1 + 3 + 2 + 1 + 3 = 10. Let me recalculate: 1 + 2 + 2 + 3 + 3 = 11. Actually: 1 + 3 + 2 + 1 + 3 = 10.

Constraints

m == grid.length
n == grid[i].length
2 ≤ m, n ≤ 50
grid consists of distinct integers from 0 to m * n - 1
moveCost.length == m * n
moveCost[i].length == n
1 ≤ moveCost[i][j] ≤ 100

Visualization

Tap to expand

Asked in

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

The optimal solution uses space-optimized dynamic programming with O(m×n²) time and O(n) space. The key insight is that we only need to track minimum costs from the previous row to calculate the current row, allowing us to use rolling arrays instead of a full DP table. This approach efficiently handles the constraint that we can move from any cell in one row to any cell in the next row.

Common Approaches

✓ Brute Force (Recursive Path Exploration)

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

This approach uses recursion to explore every possible path from each cell in the first row to every cell in the last row. For each cell, we try moving to all possible cells in the next row and calculate the minimum cost path.

Dynamic Programming (Bottom-Up)

⏱️ Time: O(m*n²) Space: O(m*n)

This approach uses dynamic programming by starting from the last row and working backwards. We maintain a DP table where dp[i][j] represents the minimum cost to reach the end starting from cell (i,j). We fill the table row by row from bottom to top.

Space-Optimized Dynamic Programming (Optimal)

⏱️ Time: O(m*n²) Space: O(n)

This is the optimal approach that uses the key insight that we only need to remember the minimum costs from the previous row to calculate the current row. Instead of storing a full m×n DP table, we use just two arrays of size n that we alternate between.

Brute Force (Recursive Path Exploration) — Algorithm Steps

Start from each cell in the first row
For each current cell, try moving to all cells in the next row
Recursively calculate the minimum cost for each possible move
Return the minimum cost among all starting positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from first row

Try each cell in the first row as starting point

Recursive exploration

For each position, try all possible moves to next row

Calculate costs

Sum up cell values and movement costs for each path

Return minimum

Return the minimum cost among all explored paths

Code -

solution.c — C

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

int** parseGrid(const char* line, int* rows, int* cols) {
    int len = strlen(line);
    int i = 0;

    // First pass: count rows
    int rowCount = 0;
    for (int k = 1; k < len; k++) {
        if (line[k] == '[') rowCount++;
    }
    if (rowCount == 0) rowCount = 1;

    int** result = (int**)malloc(rowCount * sizeof(int*));
    *rows = rowCount;
    *cols = 0;

    int rowIdx = 0;
    i = 0;

    while (i < len) {
        // Find '['
        while (i < len && line[i] != '[') i++;
        i++; // skip '['
        if (i >= len) break;

        // Skip outer '[' (if next char is also '[')
        if (line[i] == '[') continue;

        // Collect row content until ']'
        char rowStr[10000];
        int rIdx = 0;
        while (i < len && line[i] != ']') {
            rowStr[rIdx++] = line[i];
            i++;
        }
        rowStr[rIdx] = '\0';
        i++; // skip ']'

        if (rIdx == 0) continue;

        // Count columns
        int colCount = 1;
        for (int k = 0; k < rIdx; k++) {
            if (rowStr[k] == ',') colCount++;
        }

        if (rowIdx == 0) *cols = colCount;

        result[rowIdx] = (int*)malloc(colCount * sizeof(int));

        // Parse numbers using strtok
        int colIdx = 0;
        char* token = strtok(rowStr, ",");
        while (token != NULL && colIdx < colCount) {
            while (*token == ' ') token++;
            result[rowIdx][colIdx] = (int)strtol(token, NULL, 10);
            colIdx++;
            token = strtok(NULL, ",");
        }

        rowIdx++;
    }

    *rows = rowIdx;
    return result;
}

int minPathCost(int** grid, int gridRows, int gridCols, int** moveCost, int moveCostRows) {
    int m = gridRows, n = gridCols;

    // Allocate DP table
    long long** dp = (long long**)malloc(m * sizeof(long long*));
    for (int i = 0; i < m; i++) {
        dp[i] = (long long*)malloc(n * sizeof(long long));
        for (int j = 0; j < n; j++) {
            dp[i][j] = LLONG_MAX;
        }
    }

    // Initialize first row
    for (int j = 0; j < n; j++) {
        dp[0][j] = grid[0][j];
    }

    // Fill DP table row by row
    for (int i = 0; i < m - 1; i++) {
        for (int j = 0; j < n; j++) {
            if (dp[i][j] == LLONG_MAX) continue;

            int currentValue = grid[i][j];

            for (int nextCol = 0; nextCol < n; nextCol++) {
                if (currentValue < moveCostRows) {
                    long long moveCostValue = moveCost[currentValue][nextCol];
                    long long totalCost = dp[i][j] + moveCostValue + grid[i + 1][nextCol];
                    if (totalCost < dp[i + 1][nextCol]) {
                        dp[i + 1][nextCol] = totalCost;
                    }
                }
            }
        }
    }

    // Find minimum in last row
    long long result = LLONG_MAX;
    for (int j = 0; j < n; j++) {
        if (dp[m - 1][j] < result) {
            result = dp[m - 1][j];
        }
    }

    // Free DP table
    for (int i = 0; i < m; i++) free(dp[i]);
    free(dp);

    return (int)result;
}

int main() {
    char gridLine[10000];
    char moveCostLine[50000];

    if (!fgets(gridLine, sizeof(gridLine), stdin)) return 1;
    if (!fgets(moveCostLine, sizeof(moveCostLine), stdin)) return 1;

    gridLine[strcspn(gridLine, "\n")] = '\0';
    moveCostLine[strcspn(moveCostLine, "\n")] = '\0';

    int gridRows, gridCols, mcRows, mcCols;
    int** grid = parseGrid(gridLine, &gridRows, &gridCols);
    int** moveCost = parseGrid(moveCostLine, &mcRows, &mcCols);

    printf("%d\n", minPathCost(grid, gridRows, gridCols, moveCost, mcRows));

    for (int i = 0; i < gridRows; i++) free(grid[i]);
    free(grid);
    for (int i = 0; i < mcRows; i++) free(moveCost[i]);
    free(moveCost);

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^m)

For each of m rows, we explore n possibilities, leading to n^m total paths

⚠ Quadratic Growth

Space Complexity

O(m)

Recursion stack depth equals the number of rows

⚡ Linearithmic Space

42.5K Views

Medium Frequency

~18 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

Brute Force (Recursive Path Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler