Beautiful Towers I - Practice Coding Problems

Beautiful Towers I - Problem

Imagine you're an architect tasked with creating a beautiful mountain-shaped skyline from a row of towers! 🏗️

You are given an array heights of n integers representing the number of bricks in n consecutive towers. Your goal is to remove some bricks to create a stunning mountain-shaped arrangement where:

Tower heights are non-decreasing up to the peak
There's one or more consecutive towers at the maximum height (the peak)
Tower heights are non-increasing after the peak

For example, arrays like [1, 2, 3, 3, 2, 1] or [1, 4, 4, 4, 1] are beautiful mountain shapes!

Your task: Return the maximum possible sum of all tower heights after creating the perfect mountain arrangement.

Input & Output

example_1.py — Python

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

› Output: 13

💡 Note: Choose index 2 as peak. Left side becomes [3,3,4] and right side becomes [4,1,1]. Total sum = 3+3+4+1+1 = 13

example_2.py — Python

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

› Output: 22

💡 Note: Choose index 3 as peak. Mountain becomes [3,5,3,9,2,2]. Total sum = 3+5+3+9+2+2 = 22

example_3.py — Python

$ Input: [3, 2, 5, 5, 2, 3]

› Output: 18

💡 Note: Choose indices 2-3 as peak plateau. Mountain becomes [3,2,5,5,2,3]. No changes needed, sum = 18

Visualization

Tap to expand

Understanding the Visualization

Original Towers

Start with towers of different heights [5,3,4,1,1]

Try Peak at Index 2

Height 4 becomes our peak, adjust surrounding towers

Build Left Side

Create non-decreasing sequence: [3,3,4]

Build Right Side

Create non-increasing sequence: [4,1,1]

Calculate Sum

Final mountain: [3,3,4,1,1] with sum = 13

Key Takeaway

🎯 Key Insight: The optimal peak position maximizes the total sum while maintaining the mountain property. Use monotonic stacks to compute contributions efficiently!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack space and DP arrays for left and right sums

⚡ Linearithmic Space

Constraints

1 ≤ heights.length ≤ 10³
1 ≤ heights[i] ≤ 10⁹
Mountain must have exactly one peak region
You can only remove bricks, never add them

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 19

The optimal solution uses monotonic stacks to efficiently compute mountain sums in O(n) time. Key insight: for any peak position, we can calculate the maximum sum by finding the contribution of each tower to both left (non-decreasing) and right (non-increasing) sides of the mountain using dynamic programming with stack optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use monotonic stacks to efficiently compute mountain sums in O(n) time
Two-Pass Dynamic Programming	O(n²)	O(n)	Calculate left and right mountain sums in two separate passes, then combine optimally
Brute Force (Try All Peaks)	O(n³)	O(1)	Try each position as peak and calculate maximum sum for that mountain

Monotonic Stack (Optimal) — Algorithm Steps

Use monotonic stack to find previous smaller element for each position
Calculate left[i] = sum of non-decreasing sequence ending at i
Use monotonic stack to find next smaller element for each position
Calculate right[i] = sum of non-increasing sequence starting at i
For each peak position: answer = max(left[i] + right[i] - heights[i])

Visualization

Tap to expand

Step-by-Step Walkthrough

Left Stack

Find previous smaller elements using monotonic increasing stack

Right Stack

Find next smaller elements using monotonic increasing stack

DP Calculation

Use stack results to compute left and right sums in O(1) per position

Code -

solution.c — C

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

long long maximumSumOfHeights(int* heights, int n) {
    long long* left = (long long*)calloc(n, sizeof(long long));
    long long* right = (long long*)calloc(n, sizeof(long long));
    int* stack = (int*)malloc(n * sizeof(int));
    int stackSize = 0;
    
    // Calculate left array using monotonic stack
    for (int i = 0; i < n; i++) {
        // Pop elements that are >= current height
        while (stackSize > 0 && heights[stack[stackSize - 1]] >= heights[i]) {
            stackSize--;
        }
        
        if (stackSize == 0) {
            // No previous smaller element
            left[i] = (long long)heights[i] * (i + 1);
        } else {
            // Previous smaller element exists
            int prevIdx = stack[stackSize - 1];
            left[i] = left[prevIdx] + (long long)heights[i] * (i - prevIdx);
        }
        
        stack[stackSize++] = i;
    }
    
    // Calculate right array using monotonic stack
    stackSize = 0;
    for (int i = n - 1; i >= 0; i--) {
        // Pop elements that are >= current height
        while (stackSize > 0 && heights[stack[stackSize - 1]] >= heights[i]) {
            stackSize--;
        }
        
        if (stackSize == 0) {
            // No next smaller element
            right[i] = (long long)heights[i] * (n - i);
        } else {
            // Next smaller element exists
            int nextIdx = stack[stackSize - 1];
            right[i] = right[nextIdx] + (long long)heights[i] * (nextIdx - i);
        }
        
        stack[stackSize++] = i;
    }
    
    // Find maximum sum
    long long maxSum = 0;
    for (int i = 0; i < n; i++) {
        long long total = left[i] + right[i] - heights[i];
        if (total > maxSum) {
            maxSum = total;
        }
    }
    
    free(left);
    free(right);
    free(stack);
    return maxSum;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int heights[1000];
    int n = 0;
    char* token = strtok(input, "[],");
    while (token != NULL) {
        heights[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%lld\n", maximumSumOfHeights(heights, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once

✓ Linear Growth

Space Complexity

O(n)

Stack space and DP arrays for left and right sums

⚡ Linearithmic Space

Constraints

1 ≤ heights.length ≤ 10³
1 ≤ heights[i] ≤ 10⁹
Mountain must have exactly one peak region
You can only remove bricks, never add them

38.2K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler