add 218

Author: luliyucoordinate

README.md

@@ -195,6 +195,7 @@ LeetCode
 |0215|[Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/) | c | [c++](./src/0215-Kth-Largest-Element-in-an-Array/0215.cpp) |[python](./src/0215-Kth-Largest-Element-in-an-Array/0215.py)|||Medium|
 |0216|[Combination Sum III](https://leetcode.com/problems/combination-sum-iii/) | c | [c++](./src/0216-Combination-Sum-III/0216.cpp) |[python](./src/0216-Combination-Sum-III/0216.py)|||Medium|
 |0217|[Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) | c | [c++](./src/0217-Contains-Duplicate/0217.cpp) |[python](./src/0217-Contains-Duplicate/0217.py)|||Easy|
+|0218|[The Skyline Problem](https://leetcode.com/problems/the-skyline-problem/) | c | [c++](./src/0218-The-Skyline-Problem/0218.cpp) |[python](./src/0218-The-Skyline-Problem/0218.py)|[go](./src/0218-The-Skyline-Problem/0218.go)|[js](./src/0218-The-Skyline-Problem/0218.js)|Hard|
 |0219|[Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/) | c | [c++](./src/0219-Contains-Duplicate-II/0219.cpp) |[python](./src/0219-Contains-Duplicate-II/0219.py)|||Easy|
 |0221|[Maximal Square](https://leetcode.com/problems/maximal-square/) | c | [c++](./src/0221-Maximal-Square/0221.cpp) |[python](./src/0221-Maximal-Square/0221.py)|[go](./src/0221-Maximal-Square/0221.go)|[js](./src/0221-Maximal-Square/0221.js)|Medium|
 |0222|[Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes/) | c | [c++](./src/0222-Count-Complete-Tree-Nodes/0222.cpp) |[python](./src/0222-Count-Complete-Tree-Nodes/0222.py)|||Medium|

src/0218-The-Skyline-Problem/0218.cpp

@@ -0,0 +1,32 @@
+class Solution 
+{
+public:
+    vector<vector<int>> getSkyline(vector<vector<int>>& buildings) 
+    {
+        vector<vector<int> > res;
+        vector<pair<int, int> > points;
+
+        for(const auto& it : buildings)
+        {
+            points.push_back({it[0], -it[2]});
+            points.push_back({it[1], it[2]});
+        }
+
+        sort(points.begin(), points.end());
+        multiset<int> height = {0};
+        int preHighest = 0;
+        int curHighest = 0;
+        for(const auto& co : points)
+        {
+            if(co.second < 0) height.insert(-co.second);
+            else height.erase(height.find(co.second));
+            curHighest = *height.rbegin();
+            if(preHighest != curHighest)
+            {
+                res.push_back({co.first, curHighest});
+                preHighest = curHighest;
+            }
+        }
+        return res;
+    }
+};

src/0218-The-Skyline-Problem/0218.go

@@ -0,0 +1,60 @@
+type IntHeap [][]int
+
+func (h IntHeap) Len() int {
+    return len(h)
+}
+
+func (h IntHeap) Less(i, j int) bool {
+    if h[i][0] == h[j][0] {
+        return h[i][1] < h[j][1]
+    }
+    return h[i][0] < h[j][0]
+}
+
+func (h IntHeap) Swap(i, j int) {
+    h[i], h[j] = h[j], h[i]
+}
+
+func (h *IntHeap) Pop() interface{} {  
+    x := (*h)[(*h).Len()-1]
+	*h = (*h)[:(*h).Len()-1]
+    return x
+}
+
+func (h *IntHeap) Push(x interface{}) {  
+    *h = append(*h, x.([]int))
+}
+
+func getSkyline(buildings [][]int) [][]int {
+    const INT_MAX = int(^uint(0) >> 1)
+    points := make([][]int, 0)
+    rSet := make(map[int]int)
+    for _, v := range buildings {
+        points = append(points, []int{v[0], -v[2], v[1]})
+        if _, ok := rSet[v[1]]; !ok {
+            points = append(points, []int{v[1], 0, 0})
+            rSet[v[1]] = 1
+        }
+    }
+    sort.Slice(points, func(a, b int) bool {
+        if points[a][0] == points[b][0] {
+            return points[a][1] < points[b][1]
+        }
+        return points[a][0] < points[b][0]
+    })
+    h := new(IntHeap)
+    heap.Push(h, []int{0, INT_MAX})
+    res := [][]int{{0, 0}}
+    for _, v := range points {
+        for (*h)[0][1] <= v[0] {
+            heap.Pop(h)
+        }
+        if v[1] != 0 {
+            heap.Push(h, []int{v[1], v[2]})
+        }
+        if res[len(res) - 1][1] != -(*h)[0][0] {
+            res = append(res, []int{v[0], -(*h)[0][0]})
+        }
+    }
+    return res[1:len(res)]
+}

src/0218-The-Skyline-Problem/0218.js

@@ -0,0 +1,107 @@
+const t = 0;
+const parent = i => ((i + 1) >>> 1) - 1;
+const left = i => (i << 1) + 1;
+const right = i => (i + 1) << 1;
+
+class PriorityQueue {
+    constructor(comparator = (a, b) => a > b) {
+        this._heap = [];
+        this._comparator = comparator;
+    }
+
+    size() {
+        return this._heap.length;
+    }
+
+    isEmpty() {
+        return this.size() == 0;
+    }
+
+    peek() {
+        return this._heap[t];
+    }
+
+    push(...values) {
+        values.forEach(value => {
+            this._heap.push(value);
+            this._siftUp();
+        });
+        return this.size();
+    }
+
+    pop() {
+        const poppedValue = this.peek();
+        const bottom = this.size() - 1;
+        if (bottom > t) {
+            this._swap(t, bottom);
+        }
+        this._heap.pop();
+        this._siftDown();
+        return poppedValue;
+    }
+
+    replace(value) {
+        const replacedValue = this.peek();
+        this._heap[t] = value;
+        this._siftDown();
+        return replacedValue;
+    }
+
+    _greater(i, j) {
+        return this._comparator(this._heap[i], this._heap[j]);
+    }
+
+    _swap(i, j) {
+        [this._heap[i], this._heap[j]] = [this._heap[j], this._heap[i]];
+    }
+
+    _siftUp() {
+        let node = this.size() - 1;
+        while (node > t && this._greater(node, parent(node))) {
+            this._swap(node, parent(node));
+            node = parent(node);
+        }
+    }
+
+    _siftDown() {
+        let node = t;
+        while (
+            (left(node) < this.size() && this._greater(left(node), node)) ||
+            (right(node) < this.size() && this._greater(right(node), node))
+        ) {
+            let maxChild = (right(node) < this.size() && this._greater(right(node), left(node))) ? right(node) : left(node);
+            this._swap(node, maxChild);
+            node = maxChild;
+        }
+    }
+}
+/**
+ * @param {number[][]} buildings
+ * @return {number[][]}
+ */
+var getSkyline = function(buildings) {
+    let points = [], rSet = new Set();
+    for (let it of buildings) {
+        points.push([it[0], -it[2], it[1]]);
+        if (!rSet.has(it[1])) {
+            points.push([it[1], 0, 0])
+            rSet.add(it[1]);
+        }
+    }
+    let cmp = (a, b) => {
+        if (a[0] == b[0]) return a[1] - b[1];
+        return a[0] - b[0];
+    }
+    points.sort(cmp);
+    const q = new PriorityQueue(cmp);
+    q.push([0, Number.MAX_VALUE])
+    let res = [[0, 0]];
+    for (let it of points) {
+        while (q.peek()[1] <= it[0]) q.pop();
+        if (it[1] != 0) q.push([it[1], it[2]]);
+        if (res[res.length-1][1] != -q.peek()[0])
+            res.push([it[0], -q.peek()[0]]);
+    }
+    res.shift();
+    return res;
+};

src/0218-The-Skyline-Problem/0218.py

@@ -0,0 +1,14 @@
+import heapq
+class Solution:
+    def getSkyline(self, buildings: List[List[int]]) -> List[List[int]]:
+        points = [(L, -H, R) for L, R, H in buildings] + [(R, 0, 0) for R in set(r for _, r, _ in buildings)]
+        points.sort()
+        heap, res = [(0, float('inf'))], [[0, 0]]
+        for l, nh, r in points:
+            while heap[0][1] <= l:
+                heapq.heappop(heap)
+            if nh:
+                heapq.heappush(heap, (nh, r))
+            if res[-1][1] != -heap[0][0]:
+                res += [[l, -heap[0][0]]]
+        return res[1:]