Maximize the Total Height of Unique Towers

Maximize the Total Height of Unique Towers - Problem

You're tasked with designing a futuristic city skyline! You have n towers to build, and each tower i has a maximum possible height of maximumHeight[i].

Your goal is to assign heights to all towers such that:

Each tower has a positive integer height ≤ its maximum allowed height
No two towers can have the same height (each must be unique)
The total sum of all tower heights is maximized

Return the maximum possible sum of tower heights, or -1 if it's impossible to assign valid unique heights.

Example: If maximumHeight = [2, 3, 4, 3], you could assign heights [1, 2, 4, 3] for a total of 10, which is the maximum possible.

Input & Output

example_1.py — Basic Case

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

› Output: 10

💡 Note: Assign heights [1, 3, 4, 2]. All heights are unique, within limits, and sum to 10 (maximum possible).

example_2.py — Impossible Case

$ Input: [1, 1, 1, 1, 1]

› Output: -1

💡 Note: Cannot assign unique positive heights since all towers have maximum height 1, but we need 5 different heights.

example_3.py — Single Tower

$ Input: [5]

› Output: 5

💡 Note: Only one tower, assign it the maximum height 5.

Constraints

1 ≤ maximumHeight.length ≤ 10⁵
1 ≤ maximumHeight[i] ≤ 10⁹
Each tower must have a positive integer height
All assigned heights must be unique

Visualization

Tap to expand

Understanding the Visualization

Identify Priority

Buildings with higher limits get priority for taller assignments

Assign Greedily

Give each building the tallest height possible while maintaining uniqueness

Ensure Uniqueness

Each subsequent building gets a height 1 less than the previous

Check Feasibility

If any building would need height ≤ 0, the problem is impossible

Key Takeaway

🎯 Key Insight: By processing towers in descending order of their maximum heights and greedily assigning the highest available height to each, we guarantee both optimality and uniqueness.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a greedy strategy combined with sorting. Sort towers by maximum height in descending order, then assign heights greedily starting from the highest possible value. This ensures uniqueness and maximum sum in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(M^n)	O(n)	Generate all possible height assignments and find the maximum valid sum
Greedy with Sorting (Optimal)	O(n log n)	O(n)	Sort towers by max height descending, then greedily assign highest available heights

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible height combinations for n towers
For each combination, check if all heights are positive and within limits
Check if all heights in the combination are unique
Keep track of the maximum sum among all valid combinations
Return the maximum sum or -1 if no valid combination exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first tower

Try all heights from 1 to maximumHeight[0]

For each choice, move to next tower

Recursively assign heights to remaining towers

Check uniqueness

Ensure no height is used twice

Track maximum

Keep the best sum found so far

Code -

solution.c — C

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

int maxSum = -1;

void backtrack(int index, int* maximumHeight, int n, bool* used, int maxHeight, int currentSum) {
    if (index == n) {
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
        return;
    }
    
    for (int height = 1; height <= maximumHeight[index]; height++) {
        if (!used[height]) {
            used[height] = true;
            backtrack(index + 1, maximumHeight, n, used, maxHeight, currentSum + height);
            used[height] = false;
        }
    }
}

int maximizeHeights(int* maximumHeight, int n) {
    maxSum = -1;
    
    // Find max height to allocate used array
    int maxHeight = 0;
    for (int i = 0; i < n; i++) {
        if (maximumHeight[i] > maxHeight) {
            maxHeight = maximumHeight[i];
        }
    }
    
    bool* used = (bool*)calloc(maxHeight + 1, sizeof(bool));
    backtrack(0, maximumHeight, n, used, maxHeight, 0);
    free(used);
    
    return maxSum;
}

int main() {
    int arr[] = {2, 3, 4, 3};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", maximizeHeights(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(M^n)

Where M is the maximum height value and n is number of towers - we try all possible height assignments

✓ Linear Growth

Space Complexity

O(n)

Space for storing current combination and recursion stack

⚡ Linearithmic Space

42.3K Views

Medium-High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler