Box Stacking Problem - Problem

You are given a set of n rectangular boxes, each with width, height, and depth dimensions. Your goal is to stack these boxes to create the tallest possible tower.

Stacking Rules:

A box can be placed on top of another box only if both its width and depth are strictly smaller than the box below it
You can use any number of instances of each box type
Each box can be rotated to create different orientations (width×height×depth, height×width×depth, depth×width×height)

Return the maximum height of the tallest possible tower you can build.

Example: If you have boxes [(4,6,7), (1,2,3), (4,5,6)], you can rotate them to create orientations like (4,6,7), (6,4,7), (7,4,6), etc., then stack them optimally.

Input & Output

Example 1 — Basic Box Stacking

$ Input: boxes = [[4,6,7],[1,2,3],[4,5,6]]

› Output: 18

💡 Note: Optimal stacking: (7×4×6) base with height 6, then (6×4×7) with height 4, then (4×5×6) with height 5, then (3×1×2) with height 2. Total height: 6+4+5+2 = 17. But better: (7×4×6) base height 6 + (5×4×6) height 5 + (3×1×2) height 2 + another orientation gives 18.

Example 2 — Single Box

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

› Output: 3

💡 Note: Only one box, so we use its tallest orientation: 3×1×2 with height 3, or 2×3×1 with height 1, or 1×2×3 with height 2. Maximum is 3.

Example 3 — No Valid Stacking

$ Input: boxes = [[5,5,5],[5,5,5]]

› Output: 5

💡 Note: Both boxes have identical dimensions, so they cannot be stacked (need strictly smaller dimensions). Best we can do is use one box with height 5.

Constraints

1 ≤ boxes.length ≤ 100
1 ≤ width, height, depth ≤ 100
All dimensions are positive integers

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to generate all possible orientations of each box, sort them by base area, then use dynamic programming where each box builds upon the best available foundation. The optimal approach uses sorting + DP to achieve O(n² log n) time complexity.

Common Approaches

✓ Brute Force - Try All Combinations

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

Create all possible orientations of each box by rotating them. Then use recursion to try every valid combination of boxes, checking if each box can be placed on the previous one.

Optimized Dynamic Programming

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

Generate orientations more efficiently by ensuring width ≤ depth for consistent ordering, sort once, then use optimized DP with better space utilization.

Sort by Base Area

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

Generate all orientations, sort by base area in descending order, then use DP where each box can only stack on previously considered larger boxes.

Brute Force - Try All Combinations — Algorithm Steps

Generate all rotations of each box
Use recursion to try all valid stacking orders
For each recursive call, try placing each remaining box on top
Return maximum height found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Orientations

Create all 3 rotations of each box

Try All Orders

Recursively test each valid stacking combination

Find Maximum

Return the tallest tower height found

Code -

solution.c — C

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

int canPlace(int* bottom, int* top) {
    return top[0] < bottom[0] && top[2] < bottom[2];
}

int dfs(int* currentBox, int orientations[][3], int* used, int count) {
    int maxHeight = currentBox ? currentBox[1] : 0;
    
    for (int i = 0; i < count; i++) {
        if (!used[i] && (!currentBox || canPlace(currentBox, orientations[i]))) {
            used[i] = 1;
            int currentHeight = currentBox ? currentBox[1] : 0;
            int height = currentHeight + dfs(orientations[i], orientations, used, count);
            if (height > maxHeight) {
                maxHeight = height;
            }
            used[i] = 0;
        }
    }
    
    return maxHeight;
}

int solution(int boxes[][3], int n) {
    if (n == 0) return 0;
    
    int orientations[300][3]; // Max 100 boxes * 3 orientations
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        int w = boxes[i][0], h = boxes[i][1], d = boxes[i][2];
        orientations[count][0] = w; orientations[count][1] = h; orientations[count][2] = d; count++;
        orientations[count][0] = h; orientations[count][1] = w; orientations[count][2] = d; count++;
        orientations[count][0] = d; orientations[count][1] = w; orientations[count][2] = h; count++;
    }
    
    int used[300] = {0};
    return dfs(NULL, orientations, used, count);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int boxes[100][3];
    int n = 0;
    
    // Simple parsing: find numbers between brackets
    char* ptr = line;
    while (*ptr && n < 100) {
        if (*ptr == '[') {
            ptr++;
            if (*ptr == '[') {
                ptr++;
                sscanf(ptr, "%d,%d,%d", &boxes[n][0], &boxes[n][1], &boxes[n][2]);
                n++;
            }
        }
        ptr++;
    }
    
    printf("%d\n", solution(boxes, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n × n!)

3^n orientations and n! permutations to try all stacking orders

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth of at most n boxes

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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

Box Stacking Problem - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler