The Skyline Problem - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting events takes O(n log n), processing each event with heap operations takes O(log n) per event

⚡ Linearithmic

Space Complexity

O(n)

Space for events list and priority queue to store active building heights

⚡ Linearithmic Space

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

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
✓ 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)	O(n²)	O(n)	Check height at every x-coordinate by examining all buildings

Line Sweep with Priority Queue — Algorithm Steps

Create events: [x, height, type] where type indicates start (-1) or end (+1)
Sort events by x-coordinate, with start events before end events at same x
Process events left to right, maintaining active heights in a priority queue
When max height changes, add a key point to result
Handle edge cases like multiple buildings starting/ending at same position

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Events

Generate start/end events for all buildings

Sweep Left to Right

Process events in order, updating active heights

Track Maximum

Use priority queue to efficiently find current max height

Record Changes

Add key points when maximum height changes

Code -

solution.c — C

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

typedef struct {
    int x, height, type;
} Event;

int compareEvents(const void *a, const void *b) {
    Event *ea = (Event*)a, *eb = (Event*)b;
    if (ea->x != eb->x) return ea->x - eb->x;
    return ea->type - eb->type;
}

int** getSkyline(int** buildings, int buildingsSize, int* buildingsColSize, int* returnSize, int** returnColumnSizes) {
    Event events[2000];
    int eventCount = 0;
    
    for (int i = 0; i < buildingsSize; i++) {
        events[eventCount++] = (Event){buildings[i][0], buildings[i][2], 0}; // start
        events[eventCount++] = (Event){buildings[i][1], buildings[i][2], 1}; // end
    }
    
    qsort(events, eventCount, sizeof(Event), compareEvents);
    
    int** result = (int**)malloc(eventCount * sizeof(int*));
    *returnColumnSizes = (int*)malloc(eventCount * sizeof(int));
    int resultCount = 0;
    
    int heights[1000];
    int heightCount = 1;
    heights[0] = 0;
    
    for (int i = 0; i < eventCount; i++) {
        if (events[i].type == 0) { // start
            heights[heightCount++] = events[i].height;
        } else { // end
            for (int j = 0; j < heightCount; j++) {
                if (heights[j] == events[i].height) {
                    for (int k = j; k < heightCount - 1; k++) {
                        heights[k] = heights[k + 1];
                    }
                    heightCount--;
                    break;
                }
            }
        }
        
        int maxHeight = 0;
        for (int j = 0; j < heightCount; j++) {
            if (heights[j] > maxHeight) maxHeight = heights[j];
        }
        
        if (resultCount == 0 || maxHeight != result[resultCount-1][1]) {
            result[resultCount] = (int*)malloc(2 * sizeof(int));
            result[resultCount][0] = events[i].x;
            result[resultCount][1] = maxHeight;
            (*returnColumnSizes)[resultCount] = 2;
            resultCount++;
        }
    }
    
    *returnSize = resultCount;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting events takes O(n log n), processing each event with heap operations takes O(log n) per event

⚡ Linearithmic

Space Complexity

O(n)

Space for events list and priority queue to store active building heights

⚡ Linearithmic Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Line Sweep with Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler