The Skyline Problem

The Skyline Problem - Problem

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

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Given the locations and heights of all the buildings, return the skyline formed by these buildings collectively.

The geometric information of each building is given in the array buildings where buildings[i] = [left_i, right_i, height_i]:

left_i is the x coordinate of the left edge of the ith building.
right_i is the x coordinate of the right edge of the ith building.
height_i is the height of the ith building.

You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.

The skyline should be represented as a list of "key points" sorted by their x-coordinate in the form [[x1,y1],[x2,y2],...]. Each key point is the left endpoint of some horizontal segment in the skyline except the last point in the list, which always has a y-coordinate 0 and is used to mark the skyline's termination where the rightmost building ends. Any ground between the leftmost and rightmost buildings should be part of the skyline's contour.

Note: There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...,[2 3],[4 5],[7 5],[11 5],[12 7],...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...,[2 3],[4 5],[12 7],...]

Input & Output

Example 1 — Overlapping Buildings

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

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

💡 Note: At x=2: building 1 starts (height 10). At x=3: building 2 starts (height 15, new max). At x=7: building 2 ends (height drops to 12 from building 3). At x=9: building 1 ends (height stays 12). At x=12: building 3 ends (height drops to 0).

Example 2 — Adjacent Buildings

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

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

💡 Note: Two adjacent buildings with same height merge into one continuous skyline segment from x=0 to x=5.

Example 3 — Single Building

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

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

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

Constraints

1 ≤ buildings.length ≤ 10⁴
0 ≤ left_i < right_i ≤ 2³¹ - 1
1 ≤ height_i ≤ 2³¹ - 1
buildings is sorted by left_i in non-decreasing order

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28 U Uber 22

The key insight is to treat this as a sweep line problem where we only care about events when buildings start or end. The best approach uses a sweep line with priority queue to efficiently track the maximum height at each critical point. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force Coordinate Scanning

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

For every possible x-coordinate from leftmost to rightmost building, scan through all buildings to find the maximum height at that point. Record height changes as key points.

Sweep Line with Priority Queue

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

Create events for building start/end points, then sweep from left to right using a max heap to track active building heights. When the maximum height changes, record a key point.

Brute Force Coordinate Scanning — Algorithm Steps

Collect all unique x-coordinates from building edges
For each x-coordinate, scan all buildings to find max height
Record points where height changes from previous

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect Coordinates

Gather all building start/end points

Scan Each Point

For each x, check all buildings for max height

Record Changes

Add key points when height changes

Code -

solution.c — C

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

void parseBuildings(const char* input, int buildings[][3], int* buildingsSize) {
    *buildingsSize = 0;
    const char* p = input;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse building [left,right,height]
        if (*p == '[') {
            p++; // skip '['
            buildings[*buildingsSize][0] = (int)strtol(p, (char**)&p, 10);
            while (*p == ' ' || *p == ',') p++;
            buildings[*buildingsSize][1] = (int)strtol(p, (char**)&p, 10);
            while (*p == ' ' || *p == ',') p++;
            buildings[*buildingsSize][2] = (int)strtol(p, (char**)&p, 10);
            while (*p && *p != ']') p++; // skip to ']'
            if (*p == ']') p++;
            (*buildingsSize)++;
        } else {
            break;
        }
    }
}

int** solution(int** buildings, int buildingsSize, int* buildingsColSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (buildingsSize == 0) return NULL;
    
    // Create events structure
    typedef struct {
        int x;
        int height; // positive for start, negative for end
    } Event;
    
    Event events[2000];
    int eventCount = 0;
    
    // Add start and end events for each building
    for (int i = 0; i < buildingsSize; i++) {
        int left = buildings[i][0];
        int right = buildings[i][1]; 
        int height = buildings[i][2];
        
        events[eventCount].x = left;
        events[eventCount].height = height; // positive for start
        eventCount++;
        
        events[eventCount].x = right;
        events[eventCount].height = -height; // negative for end
        eventCount++;
    }
    
    // Sort events by x coordinate
    for (int i = 0; i < eventCount - 1; i++) {
        for (int j = i + 1; j < eventCount; j++) {
            if (events[i].x > events[j].x) {
                Event temp = events[i];
                events[i] = events[j];
                events[j] = temp;
            }
        }
    }
    
    int** result = (int**)malloc(eventCount * sizeof(int*));
    *returnColumnSizes = (int*)malloc(eventCount * sizeof(int));
    
    int activeHeights[1000];
    int activeCount = 0;
    int prevHeight = -1;
    
    int i = 0;
    while (i < eventCount) {
        int currentX = events[i].x;
        
        // Process all events at current x coordinate
        while (i < eventCount && events[i].x == currentX) {
            if (events[i].height > 0) {
                // Building starts - add height
                activeHeights[activeCount++] = events[i].height;
            } else {
                // Building ends - remove height
                int heightToRemove = -events[i].height;
                for (int j = 0; j < activeCount; j++) {
                    if (activeHeights[j] == heightToRemove) {
                        // Remove by shifting remaining elements
                        for (int k = j; k < activeCount - 1; k++) {
                            activeHeights[k] = activeHeights[k + 1];
                        }
                        activeCount--;
                        break;
                    }
                }
            }
            i++;
        }
        
        // Find current max height
        int currentMax = 0;
        for (int j = 0; j < activeCount; j++) {
            if (activeHeights[j] > currentMax) {
                currentMax = activeHeights[j];
            }
        }
        
        // Add point if this is first point or height changed
        if (prevHeight == -1 || currentMax != prevHeight) {
            result[*returnSize] = (int*)malloc(2 * sizeof(int));
            result[*returnSize][0] = currentX;
            result[*returnSize][1] = currentMax;
            (*returnColumnSizes)[*returnSize] = 2;
            (*returnSize)++;
            prevHeight = currentMax;
        }
    }
    
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int buildings[100][3];
    int buildingsSize;
    parseBuildings(input, buildings, &buildingsSize);
    
    int* buildingsColSize = (int*)malloc(buildingsSize * sizeof(int));
    for (int i = 0; i < buildingsSize; i++) buildingsColSize[i] = 3;
    
    int** buildingsPtr = (int**)malloc(buildingsSize * sizeof(int*));
    for (int i = 0; i < buildingsSize; i++) buildingsPtr[i] = buildings[i];
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(buildingsPtr, buildingsSize, buildingsColSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of O(n) coordinates, we scan O(n) buildings, and there can be O(n) coordinates

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for coordinate set and result array

⚡ Linearithmic Space

89.0K Views

Medium-High Frequency

~35 min Avg. Time

2.8K 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 Coordinate Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler