TheSkylineProblem218

Author: fluency03

src/TheSkylineProblem218.java

@@ -95,4 +95,100 @@ public int compare(int[] v1, int[] v2) {
         return res;
     }
 
+
+    /**
+     * https://leetcode.com/problems/the-skyline-problem/discuss/61192/Once-for-all-explanation-with-clean-Java-code(O(n2)time-O(n)-space)
+     */
+    public List<int[]> getSkyline2(int[][] buildings) {
+        List<int[]> result = new ArrayList<>();
+        List<int[]> height = new ArrayList<>();
+        for(int[] b:buildings) {
+            // start point has negative height value
+            height.add(new int[]{b[0], -b[2]});
+            // end point has normal height value
+            height.add(new int[]{b[1], b[2]}); 
+        }
+
+        // sort $height, based on the first value, if necessary, use the second to
+        // break ties
+        Collections.sort(height, (a, b) -> {
+                if(a[0] != b[0]) 
+                    return a[0] - b[0];
+                return a[1] - b[1];
+        });
+
+        // Use a maxHeap to store possible heights
+        Queue<Integer> pq = new PriorityQueue<>((a, b) -> (b - a));
+
+        // Provide a initial value to make it more consistent
+        pq.offer(0);
+
+        // Before starting, the previous max height is 0;
+        int prev = 0;
+
+        // visit all points in order
+        for(int[] h:height) {
+            if(h[1] < 0) { // a start point, add height
+                pq.offer(-h[1]);
+            } else {  // a end point, remove height
+                pq.remove(h[1]);
+            }
+            int cur = pq.peek(); // current max height;
+      
+            // compare current max height with previous max height, update result and 
+            // previous max height if necessary
+            if(prev != cur) {
+                result.add(new int[]{h[0], cur});
+                prev = cur;
+            }
+        }
+        return result;
+    }
+
+
+    /**
+     * https://leetcode.com/problems/the-skyline-problem/discuss/61281/Java-divide-and-conquer-solution-beats-96
+     */
+    public List<int[]> getSkyline3(int[][] buildings) {
+        return merge(buildings, 0, buildings.length-1);
+    }
+
+    private LinkedList<int[]> merge(int[][] buildings, int lo, int hi) {
+        LinkedList<int[]> res = new LinkedList<>();
+        if(lo > hi) {
+            return res;
+        } else if(lo == hi) {
+            res.add(new int[]{buildings[lo][0], buildings[lo][2]});
+            res.add(new int[]{buildings[lo][1], 0});
+            return res;
+        } 
+        int mid = lo+(hi-lo)/2;
+        LinkedList<int[]> left = merge(buildings, lo, mid);
+        LinkedList<int[]> right = merge(buildings, mid+1, hi);
+        int leftH = 0, rightH = 0;
+        while(!left.isEmpty() || !right.isEmpty()) {
+            long x1 = left.isEmpty()? Long.MAX_VALUE: left.peekFirst()[0];
+            long x2 = right.isEmpty()? Long.MAX_VALUE: right.peekFirst()[0];
+            int x = 0;
+            if(x1 < x2) {
+                int[] temp = left.pollFirst();
+                x = temp[0];
+                leftH = temp[1];
+            } else if(x1 > x2) {
+                int[] temp = right.pollFirst();
+                x = temp[0];
+                rightH = temp[1];
+            } else {
+                x = left.peekFirst()[0];
+                leftH = left.pollFirst()[1];
+                rightH = right.pollFirst()[1];
+            }
+            int h = Math.max(leftH, rightH);
+            if(res.isEmpty() || h != res.peekLast()[1]) {
+                res.add(new int[]{x, h});
+            }
+        }
+        return res;
+    }
+
 }