Beautiful Towers II - Practice Coding Problems

Beautiful Towers II - Problem

Imagine you're an architect tasked with designing a stunning skyline along a coordinate line. You have n positions where you must build towers, and each position i has a maximum height constraint maxHeights[i].

Your goal is to create a beautiful mountain-shaped configuration that maximizes the total height sum. A configuration is considered beautiful when:

Each tower's height is between 1 and maxHeights[i]
The heights form a mountain array - they increase up to a peak, then decrease

Mountain Array Definition: There exists a peak index i where heights are non-decreasing from left to peak (heights[j-1] ≤ heights[j] for all j ≤ i) and non-increasing from peak to right (heights[k] ≥ heights[k+1] for all k ≥ i).

Return the maximum possible sum of heights for a beautiful tower configuration.

Input & Output

basic_mountain.py — Python

$ Input: maxHeights = [5,3,4,1,1]

› Output: 13

💡 Note: One optimal configuration is heights = [2,3,3,1,1] with peak at index 1 or 2. The sum is 2+3+3+1+1 = 10. Actually, the optimal is [4,3,4,1,1] = 13 with peak at index 0 or 2.

increasing_array.py — Python

$ Input: maxHeights = [6,5,3,9,2,7]

› Output: 22

💡 Note: One optimal configuration is heights = [3,5,3,3,2,2] with peak at index 1. Sum = 3+5+3+3+2+2 = 18. Better: [6,5,3,3,2,2] = 21 or [3,3,3,9,2,2] = 22 with peak at index 3.

single_element.py — Python

$ Input: maxHeights = [3]

› Output: 3

💡 Note: With only one tower, the optimal height is the maximum allowed height 3, giving sum = 3.

Visualization

Tap to expand

Understanding the Visualization

Identify Constraints

Each position has a maximum height limit that restricts our building options

Try Different Peaks

For each potential peak, calculate the optimal left and right slopes

Optimize with Stacks

Use monotonic stacks to avoid recalculating overlapping slope contributions

Key Takeaway

🎯 Key Insight: The optimal peak position creates the tallest mountain by balancing the constraints on both left and right slopes, maximizing the total area under the mountain curve.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once, two passes through array

✓ Linear Growth

Space Complexity

O(n)

Space for monotonic stacks and left/right contribution arrays

⚡ Linearithmic Space

Constraints

1 ≤ maxHeights.length ≤ 10⁵
1 ≤ maxHeights[i] ≤ 10⁹
The answer is guaranteed to fit in a 64-bit integer

Asked in

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

The optimal solution uses monotonic stacks to efficiently compute left and right mountain contributions in O(n) time. Key insight: for each potential peak position, we need the sum of optimal left slope + optimal right slope, which can be precomputed using stack-based dynamic programming.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Peak)	O(n²)	O(1)	Try each position as peak, calculate optimal mountain sum for each
Monotonic Stack (Optimal)	O(n)	O(n)	Use monotonic stacks to compute left and right contributions efficiently

Brute Force (Try Every Peak) — Algorithm Steps

Iterate through each position as potential peak
For each peak, calculate left slope sum by going backwards
Calculate right slope sum by going forwards
Track maximum total sum across all peaks

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Peak 0

Calculate left slope (just peak) + right slope

Try Peak 1

Build optimal left and right slopes from position 1

Continue

Repeat for all positions, tracking maximum sum

Code -

solution.c — C

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

long long maximumSumOfHeights(int* maxHeights, int n) {
    long long maxSum = 0;
    
    // Try each position as peak
    for (int peak = 0; peak < n; peak++) {
        long long totalSum = 0;
        
        // Build left slope (including peak)
        long long currentHeight = maxHeights[peak];
        for (int i = peak; i >= 0; i--) {
            if (maxHeights[i] < currentHeight) {
                currentHeight = maxHeights[i];
            }
            totalSum += currentHeight;
        }
        
        // Build right slope (excluding peak)
        currentHeight = maxHeights[peak];
        for (int i = peak + 1; i < n; i++) {
            if (maxHeights[i] < currentHeight) {
                currentHeight = maxHeights[i];
            }
            totalSum += currentHeight;
        }
        
        if (totalSum > maxSum) {
            maxSum = totalSum;
        }
    }
    
    return maxSum;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions as peak, we calculate left and right slopes in O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ maxHeights.length ≤ 10⁵
1 ≤ maxHeights[i] ≤ 10⁹
The answer is guaranteed to fit in a 64-bit integer

28.4K Views

Medium Frequency

~25 min Avg. Time

680 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 Every Peak) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler