Implement the-skyline-problem

name: the-skyline-problem
url: https://leetcode.com/problems/the-skyline-problem
difficulty: 3

time: -1 ms
time-rank: 0.0 %
time-complexity: O(inf)

space: -1.0 MB
space-rank: 0.0 %
space-complexity: O(inf)

Fixes #324

This is a brute-force solution. The obvious limitation is memory.
Time is O(MN) or O(N) where M is the average width of each building.

Really horrible solution. I think that the proper one involves
interval trees, which I really know little about. I could certainly
draw the interval graph itself, and finding the starting point
and ending point is obviously easy.

The first two examples pass, but obviously [[0,2147483647,2147483647]]
throws an allocation error.

Signed-off-by: Christopher Friedt <[email protected]>

Author: cfriedt

the-skyline-problem-test.cpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2021, Christopher Friedt
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <gtest/gtest.h>
+
+#include "the-skyline-problem.cpp"
+
+using namespace std;
+
+TEST(TheSkylineProblem, 2_9_10__3_7_15__5_12_12__15_20_10__19_24_8) {
+  vector<vector<int>> buildings = {
+      {2, 9, 10}, {3, 7, 15}, {5, 12, 12}, {15, 20, 10}, {19, 24, 8}};
+  vector<vector<int>> expected = {{2, 10},  {3, 15}, {7, 12}, {12, 0},
+                                  {15, 10}, {20, 8}, {24, 0}};
+  EXPECT_EQ(expected, Solution().getSkyline(buildings));
+}
+
+TEST(TheSkylineProblem, 0_2_3__2_5_3) {
+  vector<vector<int>> buildings = {{0, 2, 3}, {2, 5, 3}};
+  vector<vector<int>> expected = {{0, 3}, {5, 0}};
+  EXPECT_EQ(expected, Solution().getSkyline(buildings));
+}
+
+#if 0
+TEST(TheSkylineProblem, 0_2147483647_2147483647) {
+  vector<vector<int>> buildings = {{0, 2147483647, 2147483647}};
+  vector<vector<int>> expected = {{2147483647, 0}};
+  EXPECT_EQ(expected, Solution().getSkyline(buildings));
+}
+#endif

the-skyline-problem.cpp

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2021, Christopher Friedt
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+// clang-format off
+// name: the-skyline-problem
+// url: https://leetcode.com/problems/the-skyline-problem
+// difficulty: 3
+// clang-format on
+
+#include <vector>
+
+using namespace std;
+
+enum {
+  LEFT,
+  RIGHT,
+  HEIGHT,
+};
+
+enum {
+  X,
+  Y,
+};
+
+template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
+  os << "[";
+  for (int i = 0, N = v.size(); i < N; ++i) {
+    os << v[i];
+    if (i < N - 1) {
+      os << ",";
+    }
+  }
+  os << "]";
+  return os;
+}
+
+class Solution {
+public:
+  vector<vector<int>> getSkyline(vector<vector<int>> &B) {
+    vector<vector<int>> S;
+    int xmin = B[0][LEFT];
+    int xmax = xmin;
+
+    for (auto &b : B) {
+      xmax = max(xmax, b[RIGHT]);
+    }
+
+    vector<int> h(xmax - xmin + 1, 0);
+    for (auto &b : B) {
+      for (auto x = b[LEFT]; x <= b[RIGHT]; ++x) {
+        h[x - xmin] = max(h[x - xmin], b[HEIGHT]);
+      }
+    }
+
+    // cout << "h: " << h << endl;
+
+    S.push_back(vector<int>{xmin, h[0]});
+    for (int x = xmin + 1; x <= xmax; ++x) {
+      auto &h_curr = h[x - xmin];
+      auto &h_prev = h[x - xmin - 1];
+
+      if (h_curr == h_prev) {
+        continue;
+      }
+
+      if (h_curr > h_prev) {
+        S.push_back(vector<int>{x, h_curr});
+      } else {
+        S.push_back(vector<int>{x - 1, h_curr});
+      }
+
+      // cout << "S: " << S << endl;
+    }
+
+    S.push_back(vector<int>{xmax, 0});
+
+    // cout << "S: " << S << endl;
+
+    return S;
+  }
+};