My code:

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

public class Solution {
    private class Edge {
        int height;
        int x;
        boolean isStart;
        
        Edge(int x, int height, boolean isStart) {
            this.x = x;
            this.height = height;
            this.isStart = isStart;
        }
    }
    
    
    public List<int[]> getSkyline(int[][] buildings) {
        List<int[]> ret = new ArrayList<int[]>();
        if (buildings == null || buildings.length == 0 || buildings[0].length == 0) {
            return ret;
        }
        
        List<Edge> edges = new ArrayList<Edge>();
        for (int i = 0; i < buildings.length; i++) {
            edges.add(new Edge(buildings[i][0], buildings[i][2], true));
            edges.add(new Edge(buildings[i][1], buildings[i][2], false));
        }
        
        Collections.sort(edges, new Comparator<Edge>() {
            public int compare(Edge e1, Edge e2) {
                if (e1.x != e2.x) {
                    return e1.x - e2.x;
                }
                else if (e1.isStart && e2.isStart) {
                    return e2.height - e1.height;
                }
                else if (!e1.isStart && !e2.isStart) {
                    return e1.height - e2.height;
                }
                else {
                    return e1.isStart ? -1 : 1;
                }
            }    
        });
        
        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(10, new Comparator<Integer>() {
            public int compare(Integer e1, Integer e2) {
                return e2.compareTo(e1);
            }    
        });
        
        for (Edge edge : edges) {
            if (edge.isStart) {
                if (pq.isEmpty() || edge.height > pq.peek()) {
                    ret.add(new int[]{edge.x, edge.height});
                }
                pq.offer(edge.height);
            }
            else {
                pq.remove(edge.height);
                if (pq.isEmpty()) {
                    ret.add(new int[]{edge.x, 0});
                }
                else if (edge.height > pq.peek()) {
                    ret.add(new int[]{edge.x, pq.peek()});
                }
            }
        }
        
        return ret;
    }
}

reference:
http://www.programcreek.com/2014/06/leetcode-the-skyline-problem-java/

这道题目看了将近一个半小时。终于基本理解了在做什么。
首先， skyline 的点分为两种：
升序时候的 skyline 点 只可能是左侧点
降序时候的 skyline 点 只可能是右侧点

所以每当我们遇到一个更高的左侧点时，他一定是一个 skyline 点
每当我们遇到一个右侧点，高度比当前大楼都高时，就意味着要开始下降了，他也一定是一个 skyline 点。
所以我们要有一个最大堆，用来存放当前大楼的高度。top就是当前大楼的最大高度。

我们有个类 Edge,表示点，以及这个点是左侧点还是右侧点
然后我们把所有的输入转换成这些点，一个大楼有两个点。
然后排序。遵守的原则是
1 . 如果 e1.x != e2.x
那么谁小谁放前面。
2 . 如果相等
那么就有讲究了。
如果同时左边点。应该先遍历哪个呢？
如果把height 矮一些的放前面，那么这个点就会变成一个 skyline 点
然后height 更高的又出现了，又会有一个skyline点，在刚刚那个点的垂直上方。这是不对的。
所以先把 height 高一些的放前面。这样，矮一些的就不会产生skyline 点

如果同时右边点。
如果把高的放前面，那么高的会在矮的高度处产生一个skyline点
然后矮的在地平线处产生一个 skyline 点。这是不对的。
所以矮的放前面，因为高的仍然在堆里，所以矮的无法产生skyline点，然后再轮到高的，在地平线处产生一个skyline 点。

如果一个是左边点，一个是右边点。
如果把右边点放在前面，会在地平线处产生一个skyline 点，然后再进入左边点，于是在左边点处产生一个 skyline 点。于是一个垂直方向上，同时出现了两个点，是不对的。
如果把左边点放在前面，如果右边点高度比他高，那么左边点不会产生skyline 点，然后右边点产生了skyline 点，下降。
如果右边点比他低，那么左边点产生一个skyline 点，上升。然后右边点发现当前top的高度比他高，无法产生skyline 点。

Anyway, Good luck, Richardo! -- 09/29/2016