Max Increase to Keep City Skyline

Max Increase to Keep City Skyline - Problem

There is a city composed of n x n blocks, where each block contains a single building shaped like a vertical square prism. You are given a 0-indexed n x n integer matrix grid where grid[r][c] represents the height of the building located in the block at row r and column c.

A city's skyline is the outer contour formed by all the buildings when viewing the side of the city from a distance. The skyline from each cardinal direction north, east, south, and west may be different.

We are allowed to increase the height of any number of buildings by any amount (the amount can be different per building). The height of a 0-height building can also be increased. However, increasing the height of a building should not affect the city's skyline from any cardinal direction.

Return the maximum total sum that the height of the buildings can be increased by without changing the city's skyline from any cardinal direction.

Input & Output

Example 1 — Basic 2x2 Grid

$ Input: grid = [[3,0],[2,4]]

› Output: 4

💡 Note: Row maximums: [3,4], Column maximums: [3,4]. Building at (0,1) can increase from 0 to 3 (+3), building at (1,0) can increase from 2 to 3 (+1). Total: 3+1 = 4.

Example 2 — Larger Grid

$ Input: grid = [[0,0,0],[0,0,0],[0,0,0]]

› Output: 0

💡 Note: All buildings have height 0, so row and column maximums are all 0. No increases possible while maintaining skyline.

Example 3 — Mixed Heights

$ Input: grid = [[1,2,3],[4,5,6],[7,8,9]]

› Output: 6

💡 Note: Row maximums: [3,6,9], Column maximums: [7,8,9]. Building increases: (0,0):+2, (0,1):+1, (1,0):+2, (1,1):+1. Total: 2+1+2+1 = 6.

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 50
0 ≤ grid[i][j] ≤ 100

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 f Facebook 12

The key insight is that each building's maximum height is constrained by both its row and column skylines. The greedy approach calculates row/column maximums and sets each building to min(row_max, col_max). Time: O(n²), Space: O(n)

Common Approaches

✓ Optimized

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

Brute Force - Try All Heights

⏱️ Time: O(n⁴) Space: O(1)

For each building, try all possible height increases from 0 to maximum possible, checking if the skyline remains unchanged. This involves recalculating row and column maximums after each potential change.

Greedy - Row/Column Max Constraints

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

The key insight is that each building's maximum possible height is constrained by both its row skyline and column skyline. We can increase each building to the minimum of these two constraints without affecting any skyline.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int dimensions[][2], int n) {
    double maxDiagonal = -1;
    int maxArea = -1;
    
    for (int i = 0; i < n; i++) {
        int length = dimensions[i][0];
        int width = dimensions[i][1];
        double diagonal = sqrt(length * length + width * width);
        int area = length * width;
        
        // Update if this rectangle is better
        if (diagonal > maxDiagonal || (fabs(diagonal - maxDiagonal) < 1e-9 && area > maxArea)) {
            maxDiagonal = diagonal;
            maxArea = area;
        }
    }
    
    return maxArea;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[a,b],[c,d],...] format
    int dimensions[100][2];
    int count = 0;
    char *ptr = line + 1; // Skip first [
    
    while (*ptr && count < 100) {
        if (*ptr == '[') {
            ptr++;
            dimensions[count][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            dimensions[count][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            count++;
        }
        ptr++;
    }
    
    int result = solution(dimensions, count);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

35.4K Views

Medium Frequency

~15 min Avg. Time

892 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