Warehouse Shelf Stacking - Problem

You are managing a warehouse where items need to be collected from shelves arranged in a grid. Each cell in the grid represents a shelf with a specific number of items that can be picked up.

Starting from the top-left corner (position [0,0]), you need to reach the bottom-right corner while collecting the maximum possible number of items. You can only move right or down at each step.

Given a 2D grid shelves where shelves[i][j] represents the number of items on shelf at position [i,j], return the maximum number of items you can collect on your path from top-left to bottom-right.

Input & Output

Example 1 — Basic 2x3 Grid

$ Input: shelves = [[1,3,1],[1,5,1]]

› Output: 10

💡 Note: Path: (0,0)→(0,1)→(1,1)→(1,2) collecting 1+3+5+1 = 10 items. This is better than going (0,0)→(1,0)→(1,1)→(1,2) which gives 1+1+5+1 = 8 items.

Example 2 — Single Row

$ Input: shelves = [[1,2,3,4]]

› Output: 10

💡 Note: Only one path possible: move right through all cells collecting 1+2+3+4 = 10 items.

Example 3 — Single Column

$ Input: shelves = [[1],[2],[3]]

› Output: 6

💡 Note: Only one path possible: move down through all cells collecting 1+2+3 = 6 items.

Constraints

1 ≤ shelves.length ≤ 200
1 ≤ shelves[i].length ≤ 200
0 ≤ shelves[i][j] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 🍎 Apple 28

The key insight is that this is a classic dynamic programming problem where each cell's optimal value depends only on the better choice between moving right or down. The optimal approach uses a 2D DP table filled bottom-up with time complexity O(m×n) and space complexity O(m×n).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Create a DP table where dp[i][j] represents the maximum items collectible from position (i,j) to bottom-right. Fill the table bottom-up and return dp[0][0].

Recursive Brute Force

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

At each cell, recursively explore both right and down moves, calculating the total items collected on each complete path. Return the maximum among all possible paths.

Top-Down Dynamic Programming (Memoization)

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

Use the same recursive approach but store results in a cache. When we encounter the same cell again, return the cached result instead of recomputing.

Bottom-Up Dynamic Programming — Algorithm Steps

Create DP table same size as grid
Initialize bottom-right corner
Fill last row and column
Fill remaining cells using recurrence relation

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Case

Set bottom-right corner value

Fill Borders

Complete last row and column with single direction

Fill Interior

Each cell = current value + max(right, down)

Code -

solution.c — C

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

int solution(int** shelves, int m, int n) {
    int** dp = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        dp[i] = malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            dp[i][j] = 0;
        }
    }
    
    // Base case
    dp[m-1][n-1] = shelves[m-1][n-1];
    
    // Fill last row
    for (int j = n-2; j >= 0; j--) {
        dp[m-1][j] = shelves[m-1][j] + dp[m-1][j+1];
    }
    
    // Fill last column
    for (int i = m-2; i >= 0; i--) {
        dp[i][n-1] = shelves[i][n-1] + dp[i+1][n-1];
    }
    
    // Fill the rest
    for (int i = m-2; i >= 0; i--) {
        for (int j = n-2; j >= 0; j--) {
            int right = dp[i][j+1];
            int down = dp[i+1][j];
            dp[i][j] = shelves[i][j] + (right > down ? right : down);
        }
    }
    
    int result = dp[0][0];
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int** shelves = malloc(10 * sizeof(int*));
    int m = 0, n = 0;
    
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        shelves[m] = malloc(10 * sizeof(int));
        n = 0;
        if (*ptr == '[') ptr++;
        
        while (*ptr && *ptr != ']') {
            shelves[m][n] = atoi(ptr);
            n++;
            while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
            if (*ptr == ',') ptr++;
        }
        m++;
        if (*ptr == ']') ptr++;
        if (*ptr == ',') ptr++;
    }
    
    int result = solution(shelves, m, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Single pass through all m×n cells with constant work per cell

✓ Linear Growth

Space Complexity

O(m×n)

DP table stores one value for each of the m×n cells

⚡ Linearithmic Space

85.0K Views

High Frequency

~15 min Avg. Time

2.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

Warehouse Shelf Stacking - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler