Put Boxes Into the Warehouse I - Practice Coding Problems

Put Boxes Into the Warehouse I - Problem

Warehouse Box Placement Challenge

You're managing a warehouse operation where you need to strategically place boxes to maximize storage efficiency. Given two arrays:

• boxes - heights of boxes you need to store
• warehouse - heights of warehouse rooms from left to right

Placement Rules:
• Boxes can only be pushed from left to right
• No stacking allowed - one box per room
• You can rearrange boxes before insertion
• If a box is too tall for a room, it and all boxes behind it are blocked

Goal: Return the maximum number of boxes you can successfully place in the warehouse.

Example: With boxes [4,3,4,1] and warehouse [5,3,3,4,1], you can place 3 boxes by choosing the right order and positions.

Input & Output

example_1.py — Basic Case

$ Input: boxes = [4,3,4,1], warehouse = [5,3,3,4,1]

› Output: 3

💡 Note: We can place 3 boxes by arranging them optimally. The effective heights are [5,3,3,3,1]. We can place boxes of height 1, 3, and 4 in positions 4, 3, and 1 respectively.

example_2.py — All Boxes Fit

$ Input: boxes = [1,2,2,3,4], warehouse = [3,4,1,2]

› Output: 3

💡 Note: Effective heights are [3,3,1,1]. We can place boxes with heights 1, 2, 3 optimally to get 3 boxes total.

example_3.py — No Boxes Fit

$ Input: boxes = [1,2,3], warehouse = [1,1,1]

› Output: 1

💡 Note: The effective height is [1,1,1] throughout. Only the box with height 1 can fit, so we can place maximum 1 box.

Constraints

n == boxes.length
m == warehouse.length
1 ≤ n, m ≤ 10⁵
1 ≤ boxes[i], warehouse[i] ≤ 10⁹
All values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Analyze Constraints

Calculate effective height at each position (running minimum)

Sort for Efficiency

Sort boxes to enable greedy placement strategy

Greedy Placement

Place smallest boxes deepest, saving large boxes for entrance area

Key Takeaway

🎯 Key Insight: The greedy approach works because placing smaller boxes deeper in the warehouse (where height constraints are tightest) leaves more flexibility for larger boxes near the entrance. This maximizes the total number of boxes we can fit.

Asked in

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

The optimal solution uses a greedy approach with sorting. First, calculate the effective heights (running minimum from left to right) to understand the real constraints at each position. Then sort boxes in ascending order and greedily place the smallest available box at the rightmost possible position. This maximizes the number of boxes by saving larger boxes for less constrained positions near the entrance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Arrangements)	O(n! × n × m)	O(n)	Generate all permutations of boxes and simulate placement for each
Greedy with Sorting (Optimal)	O(n log n + m)	O(m)	Sort boxes and greedily place them using two-pointer technique

Brute Force (Try All Arrangements) — Algorithm Steps

Generate all permutations of the boxes array
For each permutation, simulate the placement process
Track the effective height at each warehouse position
Count how many boxes can be placed for this arrangement
Return the maximum count across all arrangements

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Permutations

Create every possible ordering of boxes

Simulate Each Arrangement

For each permutation, try placing boxes left to right

Track Maximum

Keep track of the best result found

Code -

solution.c — C

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

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int canPlace(int* boxes, int boxCount, int* warehouse, int warehouseCount) {
    int* effectiveHeights = (int*)malloc(warehouseCount * sizeof(int));
    int minHeight = INT_MAX;
    
    for (int i = 0; i < warehouseCount; i++) {
        if (warehouse[i] < minHeight) {
            minHeight = warehouse[i];
        }
        effectiveHeights[i] = minHeight;
    }
    
    int count = 0, warehouseIdx = 0;
    for (int i = 0; i < boxCount; i++) {
        while (warehouseIdx < warehouseCount && boxes[i] > effectiveHeights[warehouseIdx]) {
            warehouseIdx++;
        }
        if (warehouseIdx < warehouseCount) {
            count++;
            warehouseIdx++;
        } else {
            break;
        }
    }
    
    free(effectiveHeights);
    return count;
}

void permute(int* boxes, int start, int end, int* warehouse, int warehouseCount, int* maxCount) {
    if (start == end) {
        int count = canPlace(boxes, end, warehouse, warehouseCount);
        if (count > *maxCount) {
            *maxCount = count;
        }
        return;
    }
    
    for (int i = start; i < end; i++) {
        swap(&boxes[start], &boxes[i]);
        permute(boxes, start + 1, end, warehouse, warehouseCount, maxCount);
        swap(&boxes[start], &boxes[i]);
    }
}

int maxBoxesInWarehouse(int* boxes, int boxCount, int* warehouse, int warehouseCount) {
    int maxCount = 0;
    permute(boxes, 0, boxCount, warehouse, warehouseCount, &maxCount);
    return maxCount;
}

int main() {
    int boxes[] = {4, 3, 4, 1};
    int warehouse[] = {5, 3, 3, 4, 1};
    printf("%d\n", maxBoxesInWarehouse(boxes, 4, warehouse, 5));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n × m)

n! permutations, each taking O(n×m) time to simulate placement

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

38.2K Views

Medium Frequency

~18 min Avg. Time

1.3K 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 (Try All Arrangements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler