Put Boxes Into the Warehouse II

Put Boxes Into the Warehouse II - Problem

You are given two arrays of positive integers, boxes and warehouse, representing the heights of some boxes of unit width and the heights of n rooms in a warehouse respectively.

The warehouse's rooms are labeled from 0 to n - 1 from left to right where warehouse[i] (0-indexed) is the height of the ith room.

Boxes are put into the warehouse by the following rules:

Boxes cannot be stacked.
You can rearrange the insertion order of the boxes.
Boxes can be pushed into the warehouse from either side (left or right)
If the height of some room in the warehouse is less than the height of a box, then that box and all other boxes behind it will be stopped before that room.

Return the maximum number of boxes you can put into the warehouse.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: We can place 3 boxes: box with height 1 can go anywhere, boxes with height 3 can fit in positions with height ≥3, and one box with height 4 can fit in position with height ≥4. From left: effective heights are [5,3,3,3,1]. From right: effective heights are [1,1,1,1,1]. Optimal placement yields 3 boxes.

Example 2 — Single Room

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

› Output: 1

💡 Note: Only one room available with height 3. We can place at most 1 box (any box with height ≤3). The optimal choice is to place one of the boxes with height 1, 2, or 3.

Example 3 — No Fit

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

› Output: 0

💡 Note: All boxes have height 5, but all warehouse rooms have height less than 5. No boxes can be placed.

Constraints

1 ≤ boxes.length ≤ 10⁵
1 ≤ warehouse.length ≤ 10⁵
1 ≤ boxes[i], warehouse[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 18 M Microsoft 12

The key insight is calculating effective heights from both directions and using a greedy two-pointer approach. Best approach is Greedy Two Pointers with sorted boxes. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force

⏱️ Time: O(n! × 2^n × n) Space: O(n)

Generate all possible ways to insert boxes from left and right sides, checking each combination to find the maximum number that fit. This involves trying every permutation of boxes and every possible split between left and right insertion.

Greedy Two Pointers

⏱️ Time: O(n log n) Space: O(n)

Calculate the effective maximum height from both left and right directions, sort boxes, then use two pointers to greedily place the smallest boxes in the best available positions from either side.

Brute Force — Algorithm Steps

Generate all permutations of boxes
For each permutation, try all possible left/right splits
Simulate insertion from both sides
Track maximum boxes placed

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orderings of boxes

Try All Splits

For each ordering, try all left/right divisions

Find Maximum

Track the best result across all combinations

Code -

solution.c — C

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

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

int max(int a, int b) {
    return a > b ? a : b;
}

int simulateInsertion(int* leftBoxes, int leftLen, int* rightBoxes, int rightLen, int* leftHeights, int* rightHeights, int n) {
    bool* occupied = calloc(n, sizeof(bool));
    int placed = 0;
    
    // Insert from left
    int leftIdx = 0;
    for (int i = 0; i < leftLen; i++) {
        int box = leftBoxes[i];
        while (leftIdx < n && (occupied[leftIdx] || leftHeights[leftIdx] < box)) {
            leftIdx++;
        }
        if (leftIdx < n) {
            occupied[leftIdx] = true;
            placed++;
            leftIdx++;
        } else {
            break;
        }
    }
    
    // Insert from right
    int rightIdx = n - 1;
    for (int i = 0; i < rightLen; i++) {
        int box = rightBoxes[i];
        while (rightIdx >= 0 && (occupied[rightIdx] || rightHeights[rightIdx] < box)) {
            rightIdx--;
        }
        if (rightIdx >= 0) {
            occupied[rightIdx] = true;
            placed++;
            rightIdx--;
        } else {
            break;
        }
    }
    
    free(occupied);
    return placed;
}

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

bool nextPermutation(int* arr, int n) {
    int i = n - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) i--;
    if (i < 0) return false;
    
    int j = n - 1;
    while (arr[j] <= arr[i]) j--;
    swap(&arr[i], &arr[j]);
    
    int left = i + 1, right = n - 1;
    while (left < right) {
        swap(&arr[left], &arr[right]);
        left++;
        right--;
    }
    return true;
}

int solution(int* boxes, int boxesSize, int* warehouse, int warehouseSize) {
    int n = warehouseSize;
    
    // Calculate effective heights from both sides
    int* leftHeights = malloc(n * sizeof(int));
    int* rightHeights = malloc(n * sizeof(int));
    
    // From left: each position limited by minimum height so far
    leftHeights[0] = warehouse[0];
    for (int i = 1; i < n; i++) {
        leftHeights[i] = min(leftHeights[i-1], warehouse[i]);
    }
    
    // From right: each position limited by minimum height so far
    rightHeights[n-1] = warehouse[n-1];
    for (int i = n-2; i >= 0; i--) {
        rightHeights[i] = min(rightHeights[i+1], warehouse[i]);
    }
    
    int maxBoxes = 0;
    
    // Sort for first permutation
    for (int i = 0; i < boxesSize - 1; i++) {
        for (int j = i + 1; j < boxesSize; j++) {
            if (boxes[i] > boxes[j]) {
                swap(&boxes[i], &boxes[j]);
            }
        }
    }
    
    do {
        // Try all possible splits
        for (int split = 0; split <= boxesSize; split++) {
            int placed = simulateInsertion(boxes, split, boxes + split, boxesSize - split, leftHeights, rightHeights, n);
            maxBoxes = max(maxBoxes, placed);
        }
    } while (nextPermutation(boxes, boxesSize));
    
    free(leftHeights);
    free(rightHeights);
    return maxBoxes;
}

int main() {
    char line[100000];
    static int boxes[1000], warehouse[1000];
    int boxesSize = 0, warehouseSize = 0;
    
    // Read boxes
    if (fgets(line, sizeof(line), stdin)) {
        char* p = line;
        while (*p && (*p < '0' || *p > '9') && *p != '-') p++;
        while (*p) {
            if (*p == '-' || (*p >= '0' && *p <= '9')) {
                boxes[boxesSize++] = (int)strtol(p, &p, 10);
            } else {
                p++;
            }
        }
    }
    
    // Read warehouse
    if (fgets(line, sizeof(line), stdin)) {
        char* p = line;
        while (*p && (*p < '0' || *p > '9') && *p != '-') p++;
        while (*p) {
            if (*p == '-' || (*p >= '0' && *p <= '9')) {
                warehouse[warehouseSize++] = (int)strtol(p, &p, 10);
            } else {
                p++;
            }
        }
    }
    
    int result = solution(boxes, boxesSize, warehouse, warehouseSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × 2^n × n)

n! permutations × 2^n ways to split left/right × n simulation time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing permutations and simulation state

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

892 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler