Tallest Billboard - Practice Coding Problems

Tallest Billboard - Problem

Imagine you're constructing a massive billboard that needs to be perfectly balanced with two steel supports of equal height on each side. You have a collection of steel rods with various lengths that can be welded together to create these supports.

Your goal is to maximize the height of your billboard by cleverly selecting and grouping rods to form two supports of identical height. Each rod can be used in at most one support, or not used at all.

For example, with rods of lengths [1, 2, 3, 6], you could create two supports of height 6: one using the single rod of length 6, and another by welding together rods of lengths 1, 2, and 3.

Return the maximum possible height of equal supports. If it's impossible to create two equal-height supports, return 0.

Input & Output

example_1.py — Basic Case

$ Input: rods = [1, 2, 3, 6]

› Output: 6

💡 Note: We can build two supports of height 6. Use rod of length 6 for one support, and combine rods [1,2,3] for the other support (1+2+3=6).

example_2.py — No Solution

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

› Output: 10

💡 Note: We can build two supports of height 10. One support uses rods [2,3,5] (2+3+5=10), another uses rods [4,6] (4+6=10). Rod [1] is unused.

example_3.py — Impossible Case

$ Input: rods = [1, 2]

› Output: 0

💡 Note: It's impossible to create two equal-height supports. We can't split rods, and no combination gives us equal heights.

Visualization

Tap to expand

Understanding the Visualization

Start with empty supports

Both left and right supports begin at height 0

For each rod, decide placement

Add to left support, right support, or don't use it

Track all possible differences

Use DP to efficiently explore all valid combinations

Find maximum equal height

Return the highest achievable height when difference = 0

Key Takeaway

🎯 Key Insight: Track the difference between support heights rather than absolute heights - this dramatically reduces the state space and enables efficient dynamic programming!

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each of n rods, we have 3 choices (left, right, unused), leading to 3^n combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n levels deep

⚡ Linearithmic Space

Constraints

1 ≤ rods.length ≤ 20
1 ≤ rods[i] ≤ 1000
Sum of all rod lengths ≤ 5000
Each rod can be used in at most one support or not used at all

Asked in

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

The optimal solution uses Dynamic Programming with state compression. Instead of tracking two separate support heights, we track the difference between supports and the maximum height of the shorter support for each difference. This reduces complexity from O(3^n) to O(n × sum), making it efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(3^n)	O(n)	Generate all possible ways to partition rods into two groups and check if they sum to equal heights
Dynamic Programming (Optimal)	O(n * S)	O(S)	Track all possible height differences and maximum heights achievable using memoization

Brute Force (Try All Combinations) — Algorithm Steps

Generate all 3^n possible assignments of rods (left, right, unused)
For each assignment, calculate the sum of left support and right support
If left sum equals right sum, update the maximum height
Return the maximum equal height found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty supports

Begin with both left and right supports at height 0

For each rod, branch 3 ways

Skip rod, add to left support, or add to right support

Check equality at leaf nodes

When all rods processed, check if supports have equal height

Track maximum equal height

Update result whenever we find equal supports with greater height

Code -

solution.c — C

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

int maxHeight = 0;

void backtrack(int* rods, int n, int index, int leftSum, int rightSum) {
    if (index == n) {
        if (leftSum == rightSum && leftSum > maxHeight) {
            maxHeight = leftSum;
        }
        return;
    }
    
    // Don't use current rod
    backtrack(rods, n, index + 1, leftSum, rightSum);
    
    // Use rod in left support
    backtrack(rods, n, index + 1, leftSum + rods[index], rightSum);
    
    // Use rod in right support
    backtrack(rods, n, index + 1, leftSum, rightSum + rods[index]);
}

int tallestBillboard(int* rods, int n) {
    maxHeight = 0;
    backtrack(rods, n, 0, 0, 0);
    return maxHeight;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int rods[100];
    int n = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        rods[n++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", tallestBillboard(rods, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each of n rods, we have 3 choices (left, right, unused), leading to 3^n combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is at most n levels deep

⚡ Linearithmic Space

Constraints

1 ≤ rods.length ≤ 20
1 ≤ rods[i] ≤ 1000
Sum of all rod lengths ≤ 5000
Each rod can be used in at most one support or not used at all

26.8K Views

Medium Frequency

~35 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler