A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Now suppose you aregiven the locations and height of all the buildings as shown on a cityscape photo (Figure A), write a program to output the skyline formed by these buildings collectively (Figure B).

The geometric information of each building is represented by a triplet of integers `[Li, Ri, Hi]`, where `Li` and `Ri` are the x coordinates of the left and right edge of the ith building, respectively, and `Hi` is its height. It is guaranteed that `0 ≤ Li, Ri ≤ INT_MAX``0 < Hi ≤ INT_MAX`, and `Ri - Li > 0`. You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.

For instance, the dimensions of all buildings in Figure A are recorded as: `[ [2 9 10], [3 7 15], [5 12 12], [15 20 10], [19 24 8] ] `.

The output is a list of "key points" (red dots in Figure B) in the format of `[ [x1,y1], [x2, y2], [x3, y3], ... ]` that uniquely defines a skyline. A key point is the left endpoint of a horizontal line segment. Note that the last key point, where the rightmost building ends, is merely used to mark the termination of the skyline, and always has zero height. Also, the ground in between any two adjacent buildings should be considered part of the skyline contour.

For instance, the skyline in Figure B should be represented as:`[ [2 10], [3 15], [7 12], [12 0], [15 10], [20 8], [24, 0] ]`.

Notes:

• The number of buildings in any input list is guaranteed to be in the range `[0, 10000]`.
• The input list is already sorted in ascending order by the left x position `Li`.
• The output list must be sorted by the x position.
• 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], ...]`

1. 一种是用Mergesort的原理。
1. 首先base case是当我们递归函数的lo == hi时，这时只有一个building，由一个building形成一个skyline。这里我们的两个关键点是(left, height)以及(right，0)。
2. 有了skyline之后我们就可以进行推广。每个skyline都已经是一个left sorted的doubly linkedlist。 每次由两个skyline merge成一个更大的skyline，最后一步步得出结果。 这里merge函数跟"Merge Two Sorted List" 很象。要注意merge时的各种判断，我们需要current height1和current height2来cache skyline1和skyline2的当前高度。而最后加入结果的height为Math.max(skyline1 current height，skyline2 current height)，加入结果的index为两个skyline元素中最左边的那一个，之后还要把处理过的元素从skyline1或者2，或者1和2里去除掉。所以这里用doubly-linked list很方便，其实用queue或者deque也能有一样的效果。
3. merge是一个O(n)的操作，而总算法的时间复杂度是O(nlogn)，空间复杂度是O(n)。
2. 另外一种是维护一个heap，用Sweepling Algorithm在heap里面增删改，最后输出结果。

Divide and Conquer:

Time Complexity - O(nlogn)， Space Complexity - O(n)

```public class Solution {
public List<int[]> getSkyline(int[][] buildings) {
if(buildings == null || buildings.length == 0)
return getSkyline(buildings, 0, buildings.length - 1);
}

private LinkedList<int[]> getSkyline(int[][] buildings, int lo, int hi) {
if(lo < hi) {
int mid = lo + (hi - lo) / 2;
return mergeSkylines(getSkyline(buildings, lo, mid), getSkyline(buildings, mid + 1, hi));
} else {                //  lo == hi, base case, add one building to skyline
return skyline;
}
}

private LinkedList<int[]> mergeSkylines(LinkedList<int[]> skyline1, LinkedList<int[]> skyline2) {  // merge two Skylines
int height1 = 0, height2 = 0;

while(skyline1.size() > 0 && skyline2.size() > 0) {
int index = 0, height = 0;
if(skyline1.getFirst()[0] < skyline2.getFirst()[0]) {
index = skyline1.getFirst()[0];
height1 = skyline1.getFirst()[1];
height = Math.max(height1, height2);
skyline1.removeFirst();
} else if (skyline1.getFirst()[0] > skyline2.getFirst()[0]) {
index = skyline2.getFirst()[0];
height2 = skyline2.getFirst()[1];
height = Math.max(height1, height2);
skyline2.removeFirst();
} else {
index = skyline1.getFirst()[0];
height1 = skyline1.getFirst()[1];
height2 = skyline2.getFirst()[1];
height = Math.max(height1, height2);
skyline1.removeFirst();
skyline2.removeFirst();
}
if(skyline.size() == 0 || height != skyline.getLast()[1])
}

return skyline;
}

}```

Sweeping line + Heap:  (二刷再解决)

1. 我们仍然要保存之前的height1和height2两个变量。
2. 对skyline1和skyline2中的第一个点p1和p2，我们分三种情况
1. p1[0] < p2[0]，这时候p1在p2之前出现，我们更新height1 = p1[1]，先处理p1
2. p1[0] > p2[0]，这时候p1在p2之后出现，我们更新height2 = p2[1]，先处理p2
3. 否则两点同时出现，我们更新height1和height2，同时处理两个点
4. 在height = max(height1, height2)，并且height != res.get(res.size() - 1)时，也就是当前这个点的高度不等于之前点的高度，我们把这个点加入到结果集res中。这里的一个小边界条件是当res.size() == 0时，我们也加入这个点[index, height]。
3. 在merge的最后我们要判断一下是否skyline1或者skyline2中所有的点都计算过了。 假如还有剩余点，我们对其进行处理。

Java:

Time Complexity - O(nlogn)， Space Complexity - O(n)

```public class Solution {
public List<int[]> getSkyline(int[][] buildings) {
if (buildings == null || buildings.length == 0) return new ArrayList<int[]>();
return getSkyline(buildings, 0, buildings.length - 1);
}

private List<int[]> getSkyline(int[][] buildings, int lo, int hi) {
if (lo < hi) {
int mid = lo + (hi - lo) / 2;
return mergeSkylines(getSkyline(buildings, lo, mid), getSkyline(buildings, mid + 1, hi));
} else {
List<int[]> res = new ArrayList<>();
res.add(new int[] {buildings[lo][0], buildings[lo][2]});
res.add(new int[] {buildings[lo][1], 0});
return res;
}
}

private List<int[]> mergeSkylines(List<int[]> skyline1, List<int[]> skyline2) {
List<int[]> res = new ArrayList<>();
int i = 0, j = 0;
int index = 0, height = 0, height1 = 0, height2 = 0;

while (i < skyline1.size() && j < skyline2.size()) {
int[] p1 = skyline1.get(i);
int[] p2 = skyline2.get(j);
if (p1[0] < p2[0]) {
index = p1[0];
height1 = p1[1];
i++;
} else if (p1[0] > p2[0]) {
index = p2[0];
height2 = p2[1];
j++;
} else {
index = p1[0];
height1 = p1[1];
height2 = p2[1];
i++;
j++;
}
height = Math.max(height1, height2);
if (res.size() == 0 || height != res.get(res.size() - 1)[1]) res.add(new int[] {index, height});
}

if (i < skyline1.size()) {
for (int k = i; k < skyline1.size(); k++) {
int[] p1 = skyline1.get(k);
if (p1[1] != res.get(res.size() - 1)[1]) res.add(p1);
}
} else if (j < skyline2.size()){
for (int k = j; k < skyline2.size(); k++) {
int[] p2 = skyline2.get(k);
if (p2[1] != res.get(res.size() - 1)[1]) res.add(p2);
}
}
return res;
}
}```

Reference:

https://en.wikipedia.org/wiki/Sweep_line_algorithm#Applications

http://www.algorithmist.com/index.php/UVa_105

http://www.cnblogs.com/easonliu/p/4531020.html

https://cseweb.ucsd.edu/classes/sp04/cse101/skyline.pdf

http://sandrasi-sw.blogspot.com/2012/12/the-skyline-problem.html

http://www.geeksforgeeks.org/divide-and-conquer-set-7-the-skyline-problem/

https://briangordon.github.io/2014/08/the-skyline-problem.html

https://leetcode.com/discuss/61274/17-line-log-time-space-accepted-easy-solution-explanations

https://leetcode.com/discuss/37630/my-c-code-using-one-priority-queue-812-ms

https://leetcode.com/discuss/37736/108-ms-17-lines-body-explained

https://leetcode.com/discuss/40963/share-my-divide-and-conquer-java-solution-464-ms

https://leetcode.com/discuss/54201/short-java-solution

https://leetcode.com/discuss/88149/java-solution-using-priority-queue-and-sweepline

## 218. The Skyline Problem的更多相关文章

1. [LeetCode#218] The Skyline Problem

Problem: A city's skyline is the outer contour of the silhouette formed by all the buildings in that ...

2. [LeetCode] 218. The Skyline Problem 天际线问题

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city whe ...

3. Java for LeetCode 218 The Skyline Problem【HARD】

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city whe ...

4. 218. The Skyline Problem *HARD* -- 矩形重叠

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city whe ...

5. LeetCode 218. The Skyline Problem 天际线问题(C++/Java)

题目: A city's skyline is the outer contour of the silhouette formed by all the buildings in that city ...

6. 218. The Skyline Problem (LeetCode)

天际线问题,参考自: 百草园 天际线为当前线段的最高高度,所以用最大堆处理,当遍历到线段右端点时需要删除该线段的高度,priority_queue不提供删除的操作,要用unordered_map来标记 ...

7. [LeetCode] The Skyline Problem 天际线问题

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city whe ...

8. [LeetCode] The Skyline Problem

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city whe ...

9. The Skyline Problem

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city whe ...

## 随机推荐

1. 秀才提笔忘了字：javascript使用requestAnimationFrame实现动画

requestAnimationFrame优于setTimeout/setInterval的地方在于它是由浏览器专门为动画提供的API,在运行时浏览器会自动优化方法的调用,并且如果页面不是激活状态下的 ...

2. php缓存方案

一.说说Memcached优化方案 Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提供动态.数据 ...

3. 响应式布局之BootStrap

本文在于巩固基础 学习bootStrap官网http://getbootstrap.com/ 响应式布局是Ethan Marcotte在2010年5月份提出的一个概念,简而言之,就是一个网站能够兼容多 ...

4. 转载 Mysql安装过程

目录 一.概述 二.MySQL安装 三.安装成功验证 四.NavicatforMySQL下载及使用 一.概述 MySQL版本:5.7.17 下载地址:http://rj.baidu.com/soft/ ...

5. 【转】adb shell dumpsys 命令

adb shell dumpsys,默认打印出当前系统所有service信息,在后面可加上具体的服务名 需要列出当前运行的服务,可运行: adb shell dumpsys | findstr DUM ...

6. 小试wsl

安装 管理员权限运行powershell,执行如下命令: Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Su ...

7. Django：haystack全文检索详细教程

参考:https://blog.csdn.net/AC_hell/article/details/52875927 一.安装第三方库及配置 1.1 安装插件 pip install whoosh dj ...

8. NX 栈不可执行的绕过方式--ROP链

目标程序下载 提取码:5o0a 环境:Ubuntu linux 工具 pwn-gdb pwntools python库 ROPgadget ( 这些工具可以到github官网找) 1.检查程序开了哪些 ...

9. 2018-2019-2 网络对抗技术 20165202 Exp2 后门原理与实践

博客目录 一.基础问题回答 二.实验准备:后门软件 1.Windows获得Linux Shell 2.Linux获得Windows Shell 3.使用nc传输数据 4.使用ncat实现文件传输 三. ...

10. Binary file to C array(bin2c)

/******************************************************************************** * Binary file to C ...