Max Increase to Keep City Skyline - Practice Coding Problems

Max Increase to Keep City Skyline - Problem

🏙️ Max Increase to Keep City Skyline

Imagine you're a city planner working with a n × n grid of buildings, where each cell represents the height of a building. Your goal is to maximize the total height increase of all buildings while preserving the city's iconic skyline from all four cardinal directions (north, south, east, west).

The skyline constraint means that when viewed from any direction, the tallest building in each row/column must remain the same. For example, if building at position (2,3) is the tallest in row 2, it must stay the tallest even after increases.

Key Challenge: Each building can be increased up to the minimum of:

Maximum height in its row
Maximum height in its column

Return the maximum total sum that all building heights can be increased by without changing any skyline view.

Input & Output

example_1.py — Basic 3x3 Grid

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

› Output: 35

💡 Note: Row maximums: [8,7,9,3], Column maximums: [9,4,8,7]. Each building can increase to min(row_max, col_max) for its position. Total increase = 35.

example_2.py — Uniform Heights

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

› Output: 0

💡 Note: All buildings have height 0, and all row/column maximums are 0. No building can be increased without changing the skyline.

example_3.py — Single Row Dominance

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

› Output: 0

💡 Note: Each building is already at its maximum possible height (equals min of its row max and column max), so no increases are possible.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Survey Current Skylines

Identify the tallest building in each row (east-west view) and each column (north-south view)

Calculate Growth Limits

Each building can grow up to the minimum of its row maximum and column maximum

Maximize Development

Sum all possible height increases while keeping skyline constraints

Key Takeaway

🎯 Key Insight: Precomputing row and column maximums allows us to determine each building's growth potential in constant time, achieving optimal O(n²) performance.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses a three-pass approach: precompute maximum heights for all rows and columns, then calculate increases efficiently. Key insight: each building can grow to min(row_max, col_max) while preserving all skylines. Time: O(n²), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Precompute Max Heights (Optimal)	O(n²)	O(n)	Calculate all row and column maximums once, then process each building efficiently
Brute Force (Nested Loops with Recalculation)	O(n³)	O(1)	For each building, recalculate row and column maximums every time

Precompute Max Heights (Optimal) — Algorithm Steps

First pass: Calculate maximum height for each row
Second pass: Calculate maximum height for each column
Third pass: For each building, use precomputed maximums to find increase
Sum all increases to get the total

Visualization

Tap to expand

Step-by-Step Walkthrough

Pass 1: Row Maximums

Calculate and store the maximum height in each row

Pass 2: Column Maximums

Calculate and store the maximum height in each column

Pass 3: Calculate Increases

For each building, use precomputed values to find maximum increase

Code -

solution.c — C

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

int maxIncreaseKeepingSkyline(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    
    // Precompute row maximums
    int* rowMax = (int*)calloc(n, sizeof(int));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > rowMax[i]) {
                rowMax[i] = grid[i][j];
            }
        }
    }
    
    // Precompute column maximums
    int* colMax = (int*)calloc(n, sizeof(int));
    for (int j = 0; j < n; j++) {
        for (int i = 0; i < n; i++) {
            if (grid[i][j] > colMax[j]) {
                colMax[j] = grid[i][j];
            }
        }
    }
    
    // Calculate total increase
    int totalIncrease = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int maxHeight = (rowMax[i] < colMax[j]) ? rowMax[i] : colMax[j];
            totalIncrease += maxHeight - grid[i][j];
        }
    }
    
    free(rowMax);
    free(colMax);
    return totalIncrease;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Three passes through the n×n grid: once for rows, once for columns, once for calculations

⚠ Quadratic Growth

Space Complexity

O(n)

Two arrays of size n to store row and column maximums

⚡ Linearithmic Space

38.2K Views

Medium Frequency

~15 min Avg. Time

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

🏙️ Max Increase to Keep City Skyline

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Precompute Max Heights (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler