Put Boxes Into the Warehouse II - Practice Coding Problems

Put Boxes Into the Warehouse II - Problem

Imagine you're managing a warehouse logistics operation! You have a collection of boxes with different heights and a warehouse with rooms of varying ceiling heights. Your goal is to maximize the number of boxes you can store.

You're given two arrays:

boxes - heights of boxes you need to store
warehouse - ceiling heights of warehouse rooms (indexed 0 to n-1 from left to right)

Storage Rules:

📦 Boxes cannot be stacked on top of each other
🔄 You can rearrange boxes in any order before storing
↔️ Boxes can be inserted from either the left OR right side of the warehouse
🚫 If a box is too tall for a room, it gets blocked and cannot reach rooms beyond that point

Return the maximum number of boxes you can successfully store in the warehouse.

Input & Output

example_1.py — Standard Case

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

› Output: 3

💡 Note: We can place boxes with heights [1, 3, 4]. The box with height 1 can go in room 4 (accessed from right), box with height 3 can go in rooms 1 or 2 (accessed from left), and box with height 4 can go in room 3 (accessed from right).

example_2.py — All Boxes Fit

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

› Output: 3

💡 Note: Room 2 has height 1, so boxes coming from left get blocked after room 1. From right, boxes get blocked after room 3. We can place boxes [1, 2, 2] optimally.

example_3.py — Edge Case

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

› Output: 1

💡 Note: All warehouse rooms have height 1, so we can only place the box with height 1. The boxes with heights 2 and 3 are too tall.

Constraints

1 ≤ boxes.length ≤ 10⁵
1 ≤ warehouse.length ≤ 10⁵
1 ≤ boxes[i], warehouse[i] ≤ 10⁹
Boxes can be inserted from either left or right side
Boxes cannot be stacked

Visualization

Tap to expand

Understanding the Visualization

Analyze Access Routes

Calculate how tall boxes can be when approaching from left vs right side

Sort by Priority

Sort boxes by height - smallest boxes should get priority for tight spaces

Optimal Assignment

Use two pointers to assign each box to the most restrictive available position

Key Takeaway

🎯 Key Insight: Sort boxes by height and use two pointers to greedily assign the smallest available box to the most restrictive position, maximizing total storage capacity.

Asked in

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

The optimal solution uses a two-pointers greedy approach. First, we calculate the effective height limits from both left and right sides of the warehouse. Then we sort the boxes and use two pointers to greedily place the smallest available box in the position with the most restrictive height constraint. This ensures maximum utilization with O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Greedy Optimal)	O(n log n)	O(n)	Sort boxes and use two pointers to optimally place from both warehouse ends
Brute Force (Try All Combinations)	O(2^n * n!)	O(n)	Try all possible box assignments to left/right sides with all orderings

Two Pointers (Greedy Optimal) — Algorithm Steps

Calculate effective heights from left side (minimum height encountered so far)
Calculate effective heights from right side (minimum height encountered so far)
Sort boxes in ascending order
Use two pointers to compare left and right effective heights
Place smallest box in the more restrictive position

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Left Heights

Compute minimum height reachable from left side

Calculate Right Heights

Compute minimum height reachable from right side

Sort Boxes

Sort boxes in ascending order for optimal placement

Two Pointers Placement

Use pointers to greedily place boxes in most restrictive positions

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return *(int*)a - *(int*)b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int maxBoxesInWarehouse(int* boxes, int boxesSize, int* warehouse, int warehouseSize) {
    if (warehouseSize == 0) return 0;
    
    // Calculate effective heights from left side
    int* leftHeights = (int*)malloc(warehouseSize * sizeof(int));
    leftHeights[0] = warehouse[0];
    for (int i = 1; i < warehouseSize; i++) {
        leftHeights[i] = min(leftHeights[i-1], warehouse[i]);
    }
    
    // Calculate effective heights from right side
    int* rightHeights = (int*)malloc(warehouseSize * sizeof(int));
    rightHeights[warehouseSize-1] = warehouse[warehouseSize-1];
    for (int i = warehouseSize-2; i >= 0; i--) {
        rightHeights[i] = min(rightHeights[i+1], warehouse[i]);
    }
    
    // Sort boxes in ascending order
    qsort(boxes, boxesSize, sizeof(int), compare);
    
    // Two pointers approach
    int left = 0;
    int right = warehouseSize - 1;
    int boxIdx = 0;
    int count = 0;
    
    while (left <= right && boxIdx < boxesSize) {
        if (leftHeights[left] <= rightHeights[right]) {
            if (boxes[boxIdx] <= leftHeights[left]) {
                count++;
                boxIdx++;
            }
            left++;
        } else {
            if (boxes[boxIdx] <= rightHeights[right]) {
                count++;
                boxIdx++;
            }
            right--;
        }
    }
    
    free(leftHeights);
    free(rightHeights);
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting boxes, O(n) for computing effective heights and two-pointer traversal

⚡ Linearithmic

Space Complexity

O(n)

O(n) for storing effective heights arrays and sorted boxes

⚡ Linearithmic Space

35.2K Views

High Frequency

~25 min Avg. Time

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

Two Pointers (Greedy Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler