Building Boxes

Building Boxes - Problem

You have a cubic storeroom where the width, length, and height of the room are all equal to n units. You are asked to place n boxes in this room where each box is a cube of unit side length.

There are however some rules to placing the boxes:

You can place the boxes anywhere on the floor.
If box x is placed on top of the box y, then each side of the four vertical sides of the box y must either be adjacent to another box or to a wall.

Given an integer n, return the minimum possible number of boxes touching the floor.

Input & Output

Example 1 — Small Pyramid

$ Input: n = 3

› Output: 3

💡 Note: With 3 boxes, we need all 3 on the floor since we cannot stack them optimally. Any stacking would require perfect adjacent support which isn't possible with just 3 boxes.

Example 2 — Perfect Pyramid

$ Input: n = 10

› Output: 6

💡 Note: We can build a pyramid with base layer of 6 boxes (arranged in triangular pattern 1+2+3), then add 3 boxes on second level (1+2), then 1 box on top. Total: 6+3+1 = 10 boxes.

Example 3 — Single Box

$ Input: n = 1

› Output: 1

💡 Note: With only 1 box, it must be placed on the floor. Minimum floor boxes = 1.

Constraints

1 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is to build boxes in pyramid formation to minimize floor usage. The optimal approach uses mathematical formulas for tetrahedral numbers to calculate the minimum base size directly. Time: O(∛n), Space: O(1)

Common Approaches

✓ Binary Search on Answer

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

Use binary search on the possible number of floor boxes, checking if each count can accommodate n boxes using optimal pyramid stacking.

Brute Force Simulation

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

Simulate placing boxes one by one, checking all valid positions and tracking which arrangements use the fewest floor boxes.

Mathematical Formula

⏱️ Time: O(∛n) Space: O(1)

Calculate the minimum base size needed for a pyramid that can hold exactly n boxes using mathematical formulas for tetrahedral numbers.

Binary Search on Answer — Algorithm Steps

Set search range from 1 to n floor boxes
For each candidate, check if it can hold n boxes
Binary search to find minimum valid count

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Range

Search between 1 and n floor boxes

Check Middle

Test if mid boxes can hold n total

Narrow Down

Update range based on feasibility

Code -

solution.c — C

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

int canFit(int floorBoxes, int totalBoxes) {
    int remaining = totalBoxes - floorBoxes;
    if (remaining <= 0) return 1;
    
    int h = 1;
    while (h * (h + 1) / 2 <= floorBoxes) {
        h++;
    }
    h--;
    
    if (h <= 1) return remaining <= 0;
    
    int pyramidBoxes = (h - 1) * h * (h + 1) / 6;
    return remaining <= pyramidBoxes;
}

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

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Binary search with O(1) validation per step

✓ Linear Growth

Space Complexity

O(1)

Only use constant extra variables

✓ Linear Space

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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler