Maximum Height by Stacking Cuboids - Practice Coding Problems

Maximum Height by Stacking Cuboids - Problem

Cuboid Tower Challenge

Imagine you have a collection of n cuboids (3D rectangular boxes), each with dimensions [width, length, height]. Your goal is to build the tallest possible tower by stacking some or all of these cuboids on top of each other.

The Rules:
• You can rotate any cuboid to rearrange its dimensions before stacking
• Cuboid A can be placed on cuboid B only if all dimensions of A are ≤ the corresponding dimensions of B
• You want to maximize the total height of your tower

Input: Array of cuboids where cuboids[i] = [width_i, length_i, height_i]
Output: Maximum possible height of the stacked tower

This is a classic 3D extension of the box stacking problem that combines dynamic programming with clever sorting strategies.

Input & Output

example_1.py — Basic Stacking

$ Input: cuboids = [[50,45,20],[95,37,53],[45,23,12]]

› Output: 190

💡 Note: One optimal stacking: Cuboid 1 rotated to [50,45,20], Cuboid 2 rotated to [95,53,37], and Cuboid 3 rotated to [95,23,12]. Total height = 20 + 37 + 12 = 69. Actually, better rotation gives us [95,37,53] + [50,45,20] + [45,23,12] = 53 + 20 + 12 = 85. The optimal is 190 when using all dimensions optimally.

example_2.py — No Valid Stacking

$ Input: cuboids = [[38,25,45],[76,35,3]]

› Output: 76

💡 Note: Cannot stack these cuboids due to dimension constraints. The best we can do is use the single cuboid with maximum dimension, which is 76.

example_3.py — Single Cuboid

$ Input: cuboids = [[7,11,17]]

› Output: 17

💡 Note: Only one cuboid available. The maximum dimension is 17, so that's our answer.

Constraints

n == cuboids.length
1 ≤ n ≤ 100
1 ≤ width_i, length_i, height_i ≤ 100
All dimensions are positive integers

Visualization

Tap to expand

Understanding the Visualization

Rotate & Sort

Generate all 6 rotations for each cuboid and sort dimensions

Dynamic Programming

For each position, find the best foundation from previous cuboids

Build Tower

Stack cuboids following the constraint that each upper cuboid fits within the lower one

Key Takeaway

🎯 Key Insight: Sort all rotations by dimensions, then use DP to find optimal stacking order

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses Dynamic Programming with Sorting. Key insight: Generate all possible rotations, sort by dimensions, then use DP to find the maximum stackable height. Time complexity: O(n² log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(6^n × 2^n × n!)	O(n)	Generate all possible rotations and try every stacking combination
Dynamic Programming with Sorting (Optimal)	O(n² log n)	O(n)	Sort cuboids by dimensions, then use DP to find maximum stackable height

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 6 rotations for each cuboid
Try every possible subset of rotated cuboids
For each subset, try all possible orderings
Check if each ordering satisfies stacking constraints
Track the maximum height achieved

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Rotations

Create all 6 possible rotations for each cuboid

Try Combinations

Test every possible subset and ordering

Check Validity

Verify stacking constraints for each combination

Track Maximum

Keep track of the highest valid tower

Code -

solution.c — C

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

int maxHeight = 0;

void getRotations(int* cuboid, int rotations[][3]) {
    int a = cuboid[0], b = cuboid[1], c = cuboid[2];
    int temp[][3] = {{a,b,c}, {a,c,b}, {b,a,c}, {b,c,a}, {c,a,b}, {c,b,a}};
    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 3; j++) {
            rotations[i][j] = temp[i][j];
        }
    }
}

int canStack(int* bottom, int* top) {
    return bottom[0] >= top[0] && 
           bottom[1] >= top[1] && 
           bottom[2] >= top[2];
}

void backtrack(int index, int currentStack[][3], int stackSize, 
               int currentHeight, int allRotations[][3], int totalRotations) {
    if (currentHeight > maxHeight) {
        maxHeight = currentHeight;
    }
    
    for (int i = index; i < totalRotations; i++) {
        if (stackSize == 0 || canStack(currentStack[stackSize-1], allRotations[i])) {
            for (int j = 0; j < 3; j++) {
                currentStack[stackSize][j] = allRotations[i][j];
            }
            backtrack(i+1, currentStack, stackSize+1, 
                     currentHeight + allRotations[i][2], allRotations, totalRotations);
        }
    }
}

int maxHeightCuboids(int** cuboids, int cuboidsSize) {
    maxHeight = 0;
    int allRotations[cuboidsSize * 6][3];
    
    // Generate all rotations
    for (int i = 0; i < cuboidsSize; i++) {
        int rotations[6][3];
        getRotations(cuboids[i], rotations);
        for (int j = 0; j < 6; j++) {
            for (int k = 0; k < 3; k++) {
                allRotations[i*6 + j][k] = rotations[j][k];
            }
        }
    }
    
    int currentStack[cuboidsSize * 6][3];
    backtrack(0, currentStack, 0, 0, allRotations, cuboidsSize * 6);
    return maxHeight;
}

Time & Space Complexity

Time Complexity

⏱️

O(6^n × 2^n × n!)

6^n rotations × 2^n subsets × n! orderings for each subset

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current combination and rotations

⚡ Linearithmic Space

25.7K Views

Medium Frequency

~25 min Avg. Time

856 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler