Maximum Building Height

Maximum Building Height - Problem

You want to build n new buildings in a city. The new buildings will be built in a line and are labeled from 1 to n.

However, there are city restrictions on the heights of the new buildings:

The height of each building must be a non-negative integer.
The height of the first building must be 0.
The height difference between any two adjacent buildings cannot exceed 1.

Additionally, there are city restrictions on the maximum height of specific buildings. These restrictions are given as a 2D integer array restrictions where restrictions[i] = [id_i, maxHeight_i] indicates that building id_i must have a height less than or equal to maxHeight_i.

It is guaranteed that each building will appear at most once in restrictions, and building 1 will not be in restrictions.

Return the maximum possible height of the tallest building.

Input & Output

Example 1 — Basic Case with Restriction

$ Input: n = 4, restrictions = [[2,1],[4,1]]

› Output: 2

💡 Note: Building heights: [0, 1, 0, 1]. Building 1 starts at 0, building 2 restricted to max 1, building 3 can be at most height 1+1=2 but must support building 4's max height of 1, so building 3 gets height 1+1-1=1, but actually building 3 can be height 2. Final optimal: [0, 1, 2, 1] with max height 2.

Example 2 — No Restrictions

$ Input: n = 5, restrictions = []

› Output: 2

💡 Note: Without restrictions, optimal heights are [0, 1, 2, 1, 0] or [0, 1, 2, 3, 2]. The maximum reachable height is limited by the need to return back considering adjacent differences, giving maximum height of 2 at position 3.

Example 3 — Multiple Restrictions

$ Input: n = 6, restrictions = [[3,0],[4,2]]

› Output: 1

💡 Note: Building 3 must be height 0, building 4 max height 2. Starting from building 1 at height 0, we can reach building 3 with height 0, then building 4 can be at most min(0+1, 2) = 1. Maximum achievable height is 1.

Constraints

1 ≤ n ≤ 10⁹
0 ≤ restrictions.length ≤ 1000
1 ≤ id_i ≤ n
0 ≤ maxHeight_i ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is using a two-pass greedy approach to handle bidirectional constraints. Forward pass maximizes heights from left, backward pass ensures feasibility from right. Best approach is Greedy Two-Pass. Time: O(r log r + n), Space: O(n)

Common Approaches

✓ Dp 2d

⏱️ Time: N/A Space: N/A

Memoization

⏱️ Time: N/A Space: N/A

Brute Force Simulation

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

Generate all possible height combinations for each building, check if they satisfy adjacent building constraints and specific restrictions, then find the maximum height.

Greedy Two-Pass

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

First pass builds heights as high as possible while respecting restrictions and left constraints. Second pass adjusts heights to respect right constraints, ensuring optimality.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* eventA = (int*)a;
    int* eventB = (int*)b;
    return eventA[1] - eventB[1];
}

int solution(int events[][3], int n, int k) {
    // Sort events by end time
    qsort(events, n, sizeof(events[0]), compare);
    
    // DP table: dp[i][j] = max value using first i events with at most j selections
    int dp[1001][1001] = {0};
    
    for (int i = 1; i <= n; i++) {
        int start = events[i - 1][0];
        int value = events[i - 1][2];
        
        for (int j = 1; j <= k; j++) {
            // Option 1: Skip current event
            dp[i][j] = dp[i - 1][j];
            
            // Option 2: Take current event
            // Find last event that ends before current starts
            int prevIdx = 0;
            for (int p = 0; p < i - 1; p++) {
                if (events[p][1] < start) {  // Must end BEFORE current starts
                    prevIdx = p + 1;
                }
            }
            
            int takeValue = value + dp[prevIdx][j - 1];
            if (takeValue > dp[i][j]) {
                dp[i][j] = takeValue;
            }
        }
    }
    
    return dp[n][k];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int events[1000][3];
    int n = 0;
    
    char* ptr = strchr(line, '[');
    ptr++;
    
    while (*ptr != ']' && n < 1000) {
        if (*ptr == '[') {
            ptr++;
            events[n][0] = strtol(ptr, &ptr, 10);
            ptr++;
            events[n][1] = strtol(ptr, &ptr, 10);
            ptr++;
            events[n][2] = strtol(ptr, &ptr, 10);
            n++;
            while (*ptr != ']' && *ptr != '\0') ptr++;
            if (*ptr == ']') ptr++;
            if (*ptr == ',') ptr++;
        } else {
            ptr++;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(events, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

28.0K Views

Medium Frequency

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