Maximize the Total Height of Unique Towers - Problem

You are given an array maximumHeight, where maximumHeight[i] denotes the maximum height the i-th tower can be assigned.

Your task is to assign a height to each tower so that:

The height of the i-th tower is a positive integer and does not exceed maximumHeight[i].
No two towers have the same height.

Return the maximum possible total sum of the tower heights. If it's not possible to assign heights, return -1.

Input & Output

Example 1 — Basic Case

$ Input: maximumHeight = [4,3,5]

› Output: 12

💡 Note: Optimal assignment: tower 0 gets height 4, tower 1 gets height 3, tower 2 gets height 5. All heights are unique and within limits. Sum = 4 + 3 + 5 = 12.

Example 2 — Need Height Adjustment

$ Input: maximumHeight = [6,5,3,2,5]

› Output: 20

💡 Note: Using greedy approach: sort towers by max height descending: [(6,0), (5,1), (5,4), (3,2), (2,3)]. Assign heights: tower 0 gets 6, tower 1 gets 5, tower 4 gets 4 (since 5 is taken), tower 2 gets 3, tower 3 gets 2. Final heights: [6,5,3,2,4]. Sum = 6 + 5 + 3 + 2 + 4 = 20.

Example 3 — Impossible Case

$ Input: maximumHeight = [1,1]

› Output: -1

💡 Note: Both towers have maximum height 1, but we need unique heights. Only one tower can have height 1, making it impossible to assign unique heights to both towers.

Constraints

1 ≤ maximumHeight.length ≤ 10⁵
1 ≤ maximumHeight[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 20 f Meta 15

The key insight is to use a greedy approach: sort towers by maximum height in descending order and assign the highest available unique height to each tower. This maximizes the total sum. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Assignments

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

Try every possible combination of heights for each tower, ensuring all heights are unique and within limits. This explores the entire solution space but is extremely inefficient.

Greedy - Sort and Assign

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

Sort towers by their maximum height in descending order. For each tower, assign the highest available height that doesn't exceed its limit. This greedy approach maximizes the total sum.

Brute Force - Try All Assignments — Algorithm Steps

Generate all possible height assignments
Check if assignment is valid (unique heights, within limits)
Track maximum sum among valid assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Try all possible height assignments

Validate

Check if heights are unique and within limits

Maximize

Track maximum valid sum

Code -

solution.c — C

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

int maxSum = -1;

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

int solution(int* maximumHeight, int n) {
    maxSum = -1;
    int maxHeight = 0;
    for (int i = 0; i < n; i++) {
        if (maximumHeight[i] > maxHeight) {
            maxHeight = maximumHeight[i];
        }
    }
    
    bool* usedHeights = (bool*)calloc(maxHeight + 1, sizeof(bool));
    backtrack(0, maximumHeight, n, usedHeights, maxHeight, 0);
    free(usedHeights);
    return maxSum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n^n)

For each tower, we try up to max height values, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and space to store current assignment

⚡ Linearithmic Space

18.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Maximize the Total Height of Unique Towers - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Assignments — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler