304 North Cardinal St.
Dorchester Center, MA 02124

# The Skyline Problem LeetCode Solution

## Problem – 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.

### The Skyline Problem LeetCode Solution in Java

``````	public List<int[]> getSkyline(int[][] buildings) {
List<int[]> result = new ArrayList<>();
List<int[]> height = new ArrayList<>();
for(int[] b:buildings) {
}
Collections.sort(height, (a, b) -> {
if(a != b)
return a - b;
return a - b;
});
Queue<Integer> pq = new PriorityQueue<>((a, b) -> (b - a));
pq.offer(0);
int prev = 0;
for(int[] h:height) {
if(h < 0) {
pq.offer(-h);
} else {
pq.remove(h);
}
int cur = pq.peek();
if(prev != cur) {
prev = cur;
}
}
return result;
}``````

### The Skyline Problem LeetCode Solution in Python

``````class Solution:
def getSkyline(self, buildings: List[List[int]]) -> List[List[int]]:
# for the same x, (x, -H) should be in front of (x, 0)
# For Example 2, we should process (2, -3) then (2, 0), as there's no height change
x_height_right_tuples = sorted([(L, -H, R) for L, R, H in buildings] + [(R, 0, "doesn't matter") for _, R, _ in buildings])
# (0, float('inf')) is always in max_heap, so max_heap is always valid
result, max_heap = [[0, 0]], [(0, float('inf'))]
for x, negative_height, R in x_height_right_tuples:
while x >= max_heap:
# reduce max height up to date, i.e. only consider max height in the right side of line x
heapq.heappop(max_heap)
if negative_height:
# Consider each height, as it may be the potential max height
heapq.heappush(max_heap, (negative_height, R))
curr_max_height = -max_heap
if result[-1] != curr_max_height:
result.append([x, curr_max_height])
return result[1:]
``````

### The Skyline Problem LeetCode Solution in C++

``````class Solution {
public:
vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {
vector<pair<int, int>> res;
int cur=0, cur_X, cur_H =-1,  len = buildings.size();
priority_queue< pair<int, int>> liveBlg; // first: height, second, end time
while(cur<len || !liveBlg.empty())
{ // if either some new building is not processed or live building queue is not empty
cur_X = liveBlg.empty()? buildings[cur]:liveBlg.top().second; // next timing point to process

if(cur>=len || buildings[cur] > cur_X)
{ //first check if the current tallest building will end before the next timing point
// pop up the processed buildings, i.e. those  have height no larger than cur_H and end before the top one
while(!liveBlg.empty() && ( liveBlg.top().second <= cur_X) ) liveBlg.pop();
}
else
{ // if the next new building starts before the top one ends, process the new building in the vector
cur_X = buildings[cur];
while(cur<len && buildings[cur]== cur_X)  // go through all the new buildings that starts at the same point
{  // just push them in the queue
liveBlg.push(make_pair(buildings[cur], buildings[cur]));
cur++;
}
}
cur_H = liveBlg.empty()?0:liveBlg.top().first; // outut the top one
if(res.empty() || (res.back().second != cur_H) ) res.push_back(make_pair(cur_X, cur_H));
}
return res;
}
};
``````
##### The Skyline Problem LeetCode Solution Review:

In our experience, we suggest you solve this The Skyline Problem LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the The Skyline Problem LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this The Skyline Problem LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions