Codestin Search App

The Skyline Problem - Problem

Array Divide and Conquer Binary Indexed Tree Segment Tree Line Sweep Sorting Heap (Priority Queue) Ordered Set Hard

Imagine you're standing far away from a city, looking at its magnificent skyline. What you see is the outer contour - a silhouette formed by all the buildings against the horizon.

Given an array buildings where each building is represented as [left, right, height], your task is to return the key points that define this skyline.

What makes a key point?

It's where the skyline height changes
It's the left endpoint of each horizontal segment
No consecutive points should have the same height

The result should be a list of coordinates [[x1,y1], [x2,y2], ...] sorted by x-coordinate, ending with a point at height 0 where the rightmost building ends.

Example: Buildings [[2,9,10], [3,7,15], [5,12,12]] create a skyline with key points [[2,10], [3,15], [7,12], [12,0]]

Input & Output

example_1.py — Basic skyline

$ Input: buildings = [[2,9,10],[3,7,15],[5,12,12]]

› Output: [[2,10],[3,15],[7,12],[12,0]]

💡 Note: At x=2, building 1 starts (height 10). At x=3, building 2 starts (height 15, now max). At x=7, building 2 ends, height drops to 12 from building 3. At x=12, all buildings end.

example_2.py — Single building

$ Input: buildings = [[0,2,3]]

› Output: [[0,3],[2,0]]

💡 Note: Simple case: building starts at x=0 with height 3, ends at x=2 returning to ground level 0.

example_3.py — Overlapping buildings

$ Input: buildings = [[0,2,3],[2,5,3]]

› Output: [[0,3],[5,0]]

💡 Note: Two buildings of same height are adjacent. The skyline maintains height 3 from x=0 to x=5, so we don't add a key point at x=2 where they meet.

Constraints

1 ≤ buildings.length ≤ 10⁴
0 ≤ left_i < right_i ≤ 2³¹ - 1
1 ≤ height_i ≤ 2³¹ - 1
Buildings are given as [left, right, height] where left < right

Visualization

Tap to expand

Understanding the Visualization

Mark Critical Events

Identify where buildings start and end - these are the only points where skyline can change

Sweep the Horizon

Move from left to right, processing each critical event as you encounter it

Track Active Heights

Maintain a collection of currently 'active' building heights using a priority queue

Capture Key Moments

Whenever the maximum height changes, that's a key point worth photographing

Key Takeaway

🎯 Key Insight: The skyline only changes at building boundaries, so we process start/end events with a priority queue to efficiently track the maximum height among currently active buildings.

Asked in

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

The optimal approach uses a line sweep algorithm with events and a priority queue. Create start/end events for each building, process them left-to-right while maintaining active heights in a max heap. Add key points when the maximum height changes. Time: O(n log n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Position)	O(n²)	O(n)	Check height at every x-coordinate by examining all buildings
Line Sweep with Priority Queue	O(n log n)	O(n)	Process building start/end events with priority queue to track active heights

Brute Force (Check Every Position) — Algorithm Steps

Find all unique x-coordinates (building starts and ends)
For each x-coordinate, iterate through all buildings
Find the maximum height among buildings that contain this x-coordinate
If height changes from previous position, add it as a key point
Add final point [rightmost_x, 0] to end the skyline

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Coordinates

Gather all building start and end x-coordinates

Check Each Position

For each x-coordinate, scan all buildings to find maximum height

Record Changes

Add key points where height changes from previous position

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int** getSkyline(int** buildings, int buildingsSize, int* buildingsColSize, int* returnSize, int** returnColumnSizes) {
    int coords[2000];
    int coordCount = 0;
    
    // Collect coordinates
    for (int i = 0; i < buildingsSize; i++) {
        coords[coordCount++] = buildings[i][0];
        coords[coordCount++] = buildings[i][1];
    }
    
    // Remove duplicates and sort
    qsort(coords, coordCount, sizeof(int), compare);
    int uniqueCount = 1;
    for (int i = 1; i < coordCount; i++) {
        if (coords[i] != coords[uniqueCount-1]) {
            coords[uniqueCount++] = coords[i];
        }
    }
    
    int** result = (int**)malloc(uniqueCount * sizeof(int*));
    *returnColumnSizes = (int*)malloc(uniqueCount * sizeof(int));
    int resultCount = 0;
    int prevHeight = 0;
    
    for (int i = 0; i < uniqueCount; i++) {
        int x = coords[i];
        int maxHeight = 0;
        
        for (int j = 0; j < buildingsSize; j++) {
            if (buildings[j][0] <= x && x < buildings[j][1]) {
                if (buildings[j][2] > maxHeight) {
                    maxHeight = buildings[j][2];
                }
            }
        }
        
        if (maxHeight != prevHeight) {
            result[resultCount] = (int*)malloc(2 * sizeof(int));
            result[resultCount][0] = x;
            result[resultCount][1] = maxHeight;
            (*returnColumnSizes)[resultCount] = 2;
            resultCount++;
            prevHeight = maxHeight;
        }
    }
    
    *returnSize = resultCount;
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the O(n) unique x-coordinates, we check all O(n) buildings to find maximum height

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing unique x-coordinates and result key points

⚡ Linearithmic Space

89.5K Views

Medium-High Frequency

~35 min Avg. Time

2.3K 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 (Check Every Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler