The Skyline Problem

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] = [lefti, righti, heighti]:

• lefti is the x coordinate of the left edge of the ith building.
• righti is the x coordinate of the right edge of the ith building.
• heighti 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],...]

Example 1:

Input: buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]] Output: [[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]] Explanation: Figure A shows the buildings of the input. Figure B shows the skyline formed by those buildings. The red points in figure B represent the key points in the output list.

Example 2:

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

Constraints:

• 1 <= buildings.length <= 104
• 0 <= lefti < righti <= 231 - 1
• 1 <= heighti <= 231 - 1
• buildings is sorted by lefti in non-decreasing order.

Approach: Sweep Line with a Max-Heap

Algorithm

1. Convert every building into two events: (left, -height) for the start and (right, height) for the end, so starts and ends are distinguishable
2. Sort all events by x-coordinate; when two events share an x, process the higher start first and the end of a taller building before a shorter one
3. Sweep the events left to right, using a max-heap to track the heights of all currently active buildings
4. For a start event, push the height; for an end event, remove the height from the heap
5. After processing each x, compare the current maximum height with the previous one; if it changed, a new key point (x, maxHeight) is produced

Time & Space Complexity

• Time Complexity: O(n log n) - sorting the 2n events plus heap operations
• Space Complexity: O(n) - the event list and the active-height heap

Java Implementation

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.PriorityQueue;

public class TheSkylineProblem {

    public List<List<Integer>> getSkyline(int[][] buildings) {
        List<List<Integer>> result = new ArrayList<>();
        List<int[]> height = new ArrayList<>();

        for (int[] b : buildings) {
            height.add(new int[]{b[0], -b[2]}); // start event
            height.add(new int[]{b[1], b[2]});  // end event
        }

        Collections.sort(height, (a, b) ->
                a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);

        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        pq.offer(0);
        int prev = 0;

        for (int[] h : height) {
            if (h[1] < 0) {
                pq.offer(-h[1]); // building starts
            } else {
                pq.remove(h[1]); // building ends
            }
            int cur = pq.peek();
            if (cur != prev) {
                result.add(Arrays.asList(h[0], cur));
                prev = cur;
            }
        }
        return result;
    }

    // Test method
    public static void main(String[] args) {
        TheSkylineProblem solver = new TheSkylineProblem();
        int[][] buildings = {{2, 9, 10}, {3, 7, 15}, {5, 12, 12}, {15, 20, 10}, {19, 24, 8}};
        System.out.println(solver.getSkyline(buildings));
        // Expected: [[2, 10], [3, 15], [7, 12], [12, 0], [15, 10], [20, 8], [24, 0]]
    }
}

Example Walkthrough

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

1. Events: (2,-10), (3,-15), (5,-12), (7,15), (9,10), (12,12)
2. At x=2, heap becomes {10}; max changes 0 -> 10, key point [2,10]
3. At x=3, heap becomes {15,10}; max changes 10 -> 15, key point [3,15]
4. At x=5, heap becomes {15,12,10}; max stays 15, no key point
5. At x=7, height 15 ends; heap {12,10}; max changes 15 -> 12, key point [7,12]
6. At x=9, height 10 ends; heap {12}; max stays 12, no key point
7. At x=12, height 12 ends; heap {0}; max changes 12 -> 0, key point [12,0]

Key Points

1. Event Encoding: A negative height marks the left edge, a positive one the right edge
2. Sort Order: At the same x, taller buildings start first and taller buildings end last, keeping the active set consistent
3. Max-Heap: The peek always reflects the current skyline height
4. Only Emit on Change: A key point is produced exactly when the current max height differs from the previous one, which also merges consecutive equal-height lines
5. O(n log n): The sweep line avoids the O(n²) of checking every building against every point