218. 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. Now suppose you are given 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], ...]

思路：肯定是按照event-based的思路来，最后返回的点一定是出现在矩形的边缘，那就对矩形的边缘进行检测，每次来一个边缘就进行处理，判断有没有要加入结果的点

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

/*
 * 之前是直接抄DisCuss里面答案，也没看懂，今天在youtube上看了别人的视频
 * 总算看懂了,youtube竟然有这么好的资源
 * 
 * idea：一直水平往右移动，同时看y坐标，要么上升，要么下降
 * 			维持一个最大堆，每次最大堆中的max变化时，对应的时刻就是要输出某个keypoint的时间点(想想对应的几何拓扑)
 * 如果遇到的是building的起始节点，就把数据(高度信息)插入到堆
 * 如果是building的结束节点，就把数据移除堆
 * 在这些过程中检测max的变换
 * 
 * 
 */
public class Solution {
    public List<int[]> getSkyline(int[][] buildings) {
    	List<int[]> ret = new ArrayList<int[]>();
        List<int[]> l = new ArrayList<int[]>();
        for(int[] b : buildings) {
        	l.add(new int[]{b[0], -b[2]}); //用负的高度记录start
        	l.add(new int[]{b[1], b[2]});  // 正的高度表示end
        }
        
        Collections.sort(l, new Comparator<int[]>(){
			/* 
			 * 先按照x坐标排，相同就按照高度排
			 * 1. 如果是start，当几个节点的x坐标一样时，因为高度是负的，所以高的排在前面，
			 * 			这样高的先加到最大堆并且可能输出该节点，而后面那个高度低一点的就输出不了了
			 * 2. 如果是end，高度是正的，高的在后面，前面小的高度删除时不会影响最大值（因为后面那个就比它的高度大），
			 * 			所以不输出
			 * 
			 * 而1,2这两种corner case都是符合题意的
			 */
			public int compare(int[] o1, int[] o2) {
				if(o1[0] != o2[0])
					return o1[0] - o2[0];
				return o1[1] - o2[1];
			}
        });
        
        /*
         * PriorityQueue最大堆用来保存遍历过程中overlap的高度
         * 记录当前的max和更新操作后的max
         * 最开始初始化堆时加入一个0垫底
         */
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(128, new Comparator<Integer>(){

			@Override
			public int compare(Integer o1, Integer o2) {
				return o2-o1;
			}
        	
        });
        
        
        int preMax = 0;
        pq.offer(0);		 
        for(int[] b : l) {
        	if(b[1] < 0) {
        		pq.offer(-b[1]);
        	} else {
        		pq.remove(b[1]);
        	}
        	
        	// 如果前后max变了，说明keypoint出现了
        	if(preMax != pq.peek()) {
        		ret.add(new int[]{b[0], pq.peek()});	// keypoint高度就是堆当前的max
        		preMax = pq.peek();	
        	}
        }
        
        return ret;
    }
}