Leetcode:The Skyline Problem

  1 class Solution {
  2     public List<int[]> getSkyline(int[][] buildings) {
  3         if (buildings.length == 0) {
  4             return new ArrayList<>();
  5         }
  6         
  7         CompressMap map = new CompressMap(buildings);
  8         SegmenetTree tree = new SegmenetTree(0, map.size() - 1);
  9 
 10         //Find all joint
 11         for (int i = 0, bound = buildings.length; i < bound; i++) {
 12             tree.setMin(map.get(buildings[i][0]), map.get(buildings[i][1] - 1), buildings[i][2]);
 13         }
 14         tree.toString();
 15         List<int[]> joints = new ArrayList<>(buildings.length);
 16 
 17         for (int i = tree.getLeftBound() + 1, bound = tree.getRightBound(); i <= bound; i++) {
 18             int height = tree.getMax(i, i);
 19             int[] joint = new int[]{map.reverse(i), height};
 20             joints.add(joint);
 21         }
 22 
 23         List<int[]> result = new ArrayList<>(buildings.length);
 24         result.add(joints.get(0));
 25         int lastHeight = joints.get(0)[1];
 26         for (int i = 1, bound = joints.size(); i < bound; i++) {
 27             int[] joint = joints.get(i);
 28             if (joint[1] == lastHeight) {
 29                 continue;
 30             }
 31             lastHeight = joint[1];
 32             result.add(joint);
 33         }
 34 
 35        //result.add(new int[]{map.get(tree.getRightBound()), 0});
 36         return result;
 37     }
 38 
 39     private static class CompressMap {
 40         int[] orderedValues;
 41         int length;
 42 
 43         public CompressMap(int[][] buildings) {
 44             orderedValues = new int[buildings.length * 4];
 45             for (int i = 0, bound = buildings.length; i < bound; i++) {
 46                 orderedValues[i << 2] = buildings[i][0];
 47                 orderedValues[(i << 2) | 1] = buildings[i][1];
 48                 orderedValues[(i << 2) | 2] = buildings[i][0] - 1;
 49                 orderedValues[(i << 2) | 3] = buildings[i][1] - 1;
 50             }
 51 
 52             Arrays.sort(orderedValues);
 53             length = 1;
 54             for (int i = 1, bound = orderedValues.length; i < bound; i++) {
 55                 if (orderedValues[i] != orderedValues[i - 1]) {
 56                     orderedValues[length++] = orderedValues[i];
 57                 }
 58             }
 59         }
 60 
 61         public int get(int val) {
 62             return Arrays.binarySearch(orderedValues, 0, length, val);
 63         }
 64 
 65         public int reverse(int index) {
 66             return orderedValues[index];
 67         }
 68 
 69         public int size() {
 70             return length;
 71         }
 72     }
 73 
 74     private static class SegmenetTree {
 75         int left;
 76         int right;
 77         int[] cacheValues;
 78         int[] opMarks;
 79 
 80         public SegmenetTree(int left, int right) {
 81             this.left = left;
 82             this.right = right;
 83 
 84             int proper = 1;
 85             int length = right - left + 1;
 86             while (proper < length) {
 87                 proper <<= 1;
 88             }
 89 
 90             cacheValues = new int[proper * 2];
 91             opMarks = new int[proper * 2];
 92         }
 93 
 94         public int getLeftBound() {
 95             return left;
 96         }
 97 
 98         public int getRightBound() {
 99             return right;
100         }
101 
102         public void setMin(int from, int to, int val) {
103             setMin(from, to, left, right, 1, val);
104         }
105 
106         private void setMin(int from, int to, int curLeft, int curRight, int index, int val) {
107             if (from > curRight || to < curLeft) {
108                 return;
109             }
110 
111             if (from <= curLeft && to >= curRight) {
112                 cacheValues[index] = Math.max(cacheValues[index], val);
113                 opMarks[index] = Math.max(opMarks[index], val);
114                 return;
115             }
116 
117             int mid = (curLeft + curRight) >> 1;
118             setMin(from, to, curLeft, mid, leftIndex(index), val);
119             setMin(from, to, mid + 1, curRight, rightIndex(index), val);
120             cacheValues[index] = Math.max(Math.max(cacheValues[leftIndex(index)], cacheValues[rightIndex(index)]), opMarks[index]);
121         }
122 
123         public int getMax(int from, int to) {
124             return getMax(from, to, left, right, 1);
125         }
126 
127         private int getMax(int from, int to, int curLeft, int curRight, int index) {
128             if (from <= curLeft && to >= curRight) {
129                 return cacheValues[index];
130             }
131 
132             if (from > curRight || to < curLeft) {
133                 return 0;
134             }
135 
136             int mid = (curLeft + curRight) >> 1;
137             return Math.max(Math.max(
138                     getMax(from, to, curLeft, mid, leftIndex(index)),
139                     getMax(from, to, mid + 1, curRight, rightIndex(index))
140             ), opMarks[index]);
141         }
142 
143         public int leftIndex(int i) {
144             return (i << 1);
145         }
146 
147         public int rightIndex(int i) {
148             return (i << 1) | 1;
149         }
150 
151         @Override
152         public String toString() {
153             StringBuilder builder = new StringBuilder();
154             for (int i = getLeftBound(); i < getRightBound(); i++) {
155                 builder.append(getMax(i, i)).append(",");
156             }
157             if (builder.length() > 0) {
158                 builder.setLength(builder.length() - 1);
159             }
160             return builder.toString();
161         }
162     }
163 }