Building Boxes - Practice Coding Problems

Building Boxes - Problem

You have a cubic storeroom where the width, length, and height are all equal to n units. Your task is to place exactly n unit cubes in this room following specific stacking rules.

Placement Rules:

📦 You can place boxes anywhere on the floor
🏗️ To stack a box on top of another, the bottom box must be fully supported - each of its four vertical sides must either touch another box or a wall

Goal: Find the minimum number of boxes that must touch the floor to accommodate all n boxes while following the stacking rules.

Think of it like building the most efficient warehouse storage system!

Input & Output

example_1.py — Basic Case

$ Input: n = 3

› Output: 3

💡 Note: With 3 boxes, we need all 3 on the floor since we can't create a stable pyramid. Any stacking would require the bottom box to be surrounded, which isn't possible with only 3 total boxes.

example_2.py — Small Pyramid

$ Input: n = 4

› Output: 3

💡 Note: We can place 3 boxes on the floor in a triangular arrangement, then stack the 4th box on top of the center, creating the minimal configuration.

example_3.py — Larger Case

$ Input: n = 10

› Output: 6

💡 Note: Optimal arrangement: 6 boxes on floor level, 3 boxes on second level, 1 box on third level. This creates a stable tetrahedral pyramid structure using all 10 boxes efficiently.

Visualization

Tap to expand

Understanding the Visualization

Floor Level

Start with triangular base on floor - this determines total capacity

Build Levels

Each level above has triangular number pattern: 1, 3, 6, 10, 15...

Calculate Total

Sum all complete levels plus partial level to reach exactly n boxes

Key Takeaway

🎯 Key Insight: The minimum floor boxes needed follows tetrahedral number patterns. Use mathematical formulas to directly calculate the optimal pyramid configuration rather than simulating box placement, achieving O(log n) or even O(1) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Binary search over n possible answers, each check is O(1) with math formulas

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
The storeroom is cubic with equal dimensions
All boxes are unit cubes (1×1×1)
Stacking requires full side support (box or wall contact)

Asked in

G Google 42 f Meta 28 a Amazon 35 ⊞ Microsoft 19

The optimal solution uses mathematical formulas with tetrahedral numbers to directly calculate the minimum floor boxes needed. The key insight is that boxes form pyramid levels where level k can hold at most k(k+1)/2 boxes, and we need to find the optimal configuration using binary search or direct mathematical computation in O(log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Mathematical Formula	O(log n)	O(1)	Binary search on answer with tetrahedral number calculations
Brute Force Simulation	O(n²)	O(1)	Try all possible floor configurations and simulate box placement

Binary Search + Mathematical Formula — Algorithm Steps

Binary search on the number of floor boxes (1 to n)
For each candidate, calculate max boxes using tetrahedral formulas
Find largest complete tetrahedral level that fits
Check if remaining boxes can be placed on partial level

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Search space [1, n] for minimum floor boxes

Calculate Complete Levels

Find largest tetrahedral number ≤ candidate

Check Partial Level

Verify remaining boxes fit on incomplete level

Code -

solution.c — C

#include <stdio.h>

int canPlace(int n, int floorBoxes) {
    int k = 0;
    while ((long long)(k + 1) * (k + 2) * (k + 3) / 6 <= floorBoxes) {
        k++;
    }
    
    long long totalComplete = (long long)k * (k + 1) * (k + 2) / 6;
    if (totalComplete >= n) return 1;
    
    long long remaining = n - totalComplete;
    long long maxOnNextLevel = floorBoxes - totalComplete;
    
    int j = 0;
    while ((long long)j * (j + 1) / 2 <= maxOnNextLevel && (long long)j * (j + 1) / 2 < remaining) {
        j++;
    }
    
    return totalComplete + (long long)j * (j + 1) / 2 >= n;
}

int minimumBoxes(int n) {
    int left = 1, right = n;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canPlace(n, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", minimumBoxes(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Binary search over n possible answers, each check is O(1) with math formulas

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
The storeroom is cubic with equal dimensions
All boxes are unit cubes (1×1×1)
Stacking requires full side support (box or wall contact)

28.6K Views

Medium-High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search + Mathematical Formula — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler