Maximum Height by Stacking Cuboids

Maximum Height by Stacking Cuboids - Problem

Given n cuboids where the dimensions of the ith cuboid is cuboids[i] = [width_i, length_i, height_i] (0-indexed).

Choose a subset of cuboids and place them on each other. You can place cuboid i on cuboid j if width_i <= width_j and length_i <= length_j and height_i <= height_j.

You can rearrange any cuboid's dimensions by rotating it to put it on another cuboid.

Return the maximum height of the stacked cuboids.

Input & Output

Example 1 — Basic Stacking

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

› Output: 190

💡 Note: After sorting dimensions: [[20,45,50],[37,53,95],[12,23,45]]. Sorted cuboids: [[12,23,45],[20,45,50],[37,53,95]]. We can stack all three: 45+50+95 = 190.

Example 2 — Subset Selection

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

› Output: 76

💡 Note: After sorting: [[25,38,45],[3,35,76]]. We cannot stack them (25≤3 is false), so best is single cuboid with height 76.

Example 3 — Single Cuboid

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

› Output: 17

💡 Note: Only one cuboid, maximum height is its largest dimension after rotation: max(7,11,17) = 17.

Constraints

n == cuboids.length
1 ≤ n ≤ 100
1 ≤ width_i, length_i, height_i ≤ 100

Visualization

Tap to expand

Asked in

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

The key insight is to sort dimensions within each cuboid, then sort all cuboids to enable dynamic programming. This transforms the problem into a variant of the longest increasing subsequence. Best approach uses sorting + DP with Time: O(n²), Space: O(n).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force with All Combinations

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

For each cuboid, try all 6 possible rotations, then check all possible subsets and orderings to find maximum height.

Sort Then Dynamic Programming

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

First normalize each cuboid by sorting its dimensions, then sort all cuboids. Use dynamic programming similar to longest increasing subsequence to find maximum stackable height.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int toBinary(int num, char* binary) {
    if (num == 0) {
        strcpy(binary, "0");
        return 1;
    }
    
    int len = 0;
    int temp = num;
    while (temp > 0) {
        temp /= 2;
        len++;
    }
    
    binary[len] = '\0';
    for (int i = len - 1; i >= 0; i--) {
        binary[i] = (num % 2) + '0';
        num /= 2;
    }
    return len;
}

long long binaryToDecimal(char* binary) {
    long long result = 0;
    for (int i = 0; binary[i]; i++) {
        result = result * 2 + (binary[i] - '0');
    }
    return result;
}

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

long long solution(int* nums) {
    long long maxVal = 0;
    int perms[6][3] = {{0,1,2}, {0,2,1}, {1,0,2}, {1,2,0}, {2,0,1}, {2,1,0}};
    
    for (int i = 0; i < 6; i++) {
        char binaryConcat[100] = "";
        for (int j = 0; j < 3; j++) {
            char binary[32];
            toBinary(nums[perms[i][j]], binary);
            strcat(binaryConcat, binary);
        }
        
        long long decimalVal = binaryToDecimal(binaryConcat);
        if (decimalVal > maxVal) {
            maxVal = decimalVal;
        }
    }
    
    return maxVal;
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    // Parse [a,b,c] format
    int nums[3];
    sscanf(line, "[%d,%d,%d]", &nums[0], &nums[1], &nums[2]);
    
    printf("%lld\n", solution(nums));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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