leetcode

Author: ayoubzulfiqar

README.md

@@ -61,6 +61,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
 - [Find K Closest Elements](FindKClosestElements/find_k_closest_elements.dart)
 - [Excel Sheet Column Title](ExcelSheetColumnTitle/excel_sheet_column_title.dart)
 - [Majority Element](MajorityElement/majority_element.dart)
+- [The Skyline Problem](TheSkylineProblem/the_skyline_problem.dart)
 
 ## Reach me via
 

TheSkylineProblem/the_skyline_problem.dart

@@ -0,0 +1,313 @@
+/*
+
+-* The Skyline Problem *-
+
+
+A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Given the locations and heights of all the buildings, return the skyline formed by these buildings collectively.
+
+The geometric information of each building is given in the array buildings where buildings[i] = [lefti, righti, heighti]:
+
+left-i is the x coordinate of the left edge of the ith building.
+right-i is the x coordinate of the right edge of the ith building.
+height-i is the height of the ith building.
+You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.
+
+The skyline should be represented as a list of "key points" sorted by their x-coordinate in the form [[x1,y1],[x2,y2],...]. Each key point is the left endpoint of some horizontal segment in the skyline except the last point in the list, which always has a y-coordinate 0 and is used to mark the skyline's termination where the rightmost building ends. Any ground between the leftmost and rightmost buildings should be part of the skyline's contour.
+
+Note: There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...,[2 3],[4 5],[7 5],[11 5],[12 7],...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...,[2 3],[4 5],[12 7],...]
+
+
+
+Example 1:
+
+
+Input: buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]
+Output: [[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]
+Explanation:
+Figure A shows the buildings of the input.
+Figure B shows the skyline formed by those buildings. The red points in figure B represent the key points in the output list.
+Example 2:
+
+Input: buildings = [[0,2,3],[2,5,3]]
+Output: [[0,3],[5,0]]
+
+
+Constraints:
+
+1 <= buildings.length <= 104
+0 <= left-i < right-i <= 231 - 1
+1 <= height-i <= 231 - 1
+buildings is sorted by left-i in non-decreasing order.
+
+
+
+
+*/
+
+import 'dart:math';
+
+class A {
+  List<List<int>> getSkyline(List<List<int>> buildings) {
+    int n = buildings.length;
+    List<int> keys = [];
+    for (List<int> building in buildings) {
+      keys.add(building[0]);
+      keys.add(building[1]);
+    }
+    keys.sort();
+    int last = 0;
+    int lastKey = -1;
+    List<int> temp = [];
+    List<List<int>> result = [].map((e) => <int>[]).toList();
+    for (int left in keys) {
+      if (left == lastKey) continue;
+      lastKey = left;
+      int height = 0;
+      for (List<int> building in buildings) {
+        if (left >= building[0] && left < building[1])
+          height = max(height, building[2]);
+        else if (building[0] > left) break;
+      }
+      if (height != last) {
+        temp.add(left);
+        temp.add(height);
+        result.add(temp);
+        temp.clear();
+      }
+      last = height;
+    }
+    return result;
+  }
+}
+
+class C {
+  // Time Limit exceed
+  List<List<int>> getSkyline(List<List<int>> buildings) {
+    Set new_set = Set();
+    buildings.forEach((b) {
+      new_set.add(b[0]);
+      new_set.add(b[1]);
+    });
+    List temp = List.from(new_set);
+    temp.sort((a, b) => a - b);
+    List<List<int>> result = [].map((e) => <int>[]).toList();
+    temp.forEach((x) {
+      List<List<int>> b =
+          buildings.where((b) => b[0] == x || b[0] < x && b[1] > x).toList();
+      int maxi = 0;
+      for (int i = 0; i < b.length; i++) {
+        maxi = max(maxi, b[i][2]);
+      }
+      result.add([x, maxi]);
+    });
+
+    for (int i = 1; i < result.length; i++) {
+      List<int> last = result[i - 1];
+      List<int> current = result[i];
+      if (last[1] == current[1]) {
+        result.sublist(1, i);
+        i--;
+      }
+    }
+    return result;
+  }
+}
+
+class KeyPoint {
+  int key;
+  int height;
+  KeyPoint? next = null;
+
+  KeyPoint(int this.key, int this.height);
+}
+
+class D {
+// Runtime: 592 ms, faster than 100.00% of Dart online submissions for The Skyline Problem.
+// Memory Usage: 147.5 MB, less than 100.00% of Dart online submissions for The Skyline Problem.
+
+  List<List<int>> getSkyline(List<List<int>> buildings) {
+    List<List<int>> res = [].map((e) => <int>[]).toList();
+    KeyPoint dummy = KeyPoint(-1, 0); // dummy head
+    KeyPoint pre = dummy;
+
+    for (List<int> bd in buildings) {
+      int L = bd[0];
+      int R = bd[1];
+      int H = bd[2];
+
+      while (pre.next != null && pre.next!.key <= L) pre = pre.next!;
+
+      int preH = pre.height;
+
+      if (pre.key == L)
+        pre.height = max(pre.height, H);
+      else if (pre.height < H) {
+        KeyPoint? next = pre.next;
+        pre.next = new KeyPoint(L, H);
+        pre = pre.next!;
+        pre.next = next;
+      }
+
+      KeyPoint preIter = pre;
+      KeyPoint? curIter = pre.next;
+      while (curIter != null && curIter.key < R) {
+        preH = curIter.height;
+        curIter.height = max(curIter.height, H);
+
+        if (curIter.height == preIter.height)
+          preIter.next = curIter.next;
+        else
+          preIter = curIter;
+
+        curIter = curIter.next;
+      }
+
+      if (preIter.height != preH &&
+          preIter.key != R &&
+          (curIter == null || curIter.key != R)) {
+        KeyPoint? next = preIter.next;
+        preIter.next = KeyPoint(R, preH);
+        preIter.next!.next = next;
+      }
+    }
+
+    KeyPoint? first = dummy;
+    KeyPoint? second = dummy.next;
+    while (second != null) {
+      if (second.height != first!.height)
+        //res.add(Arrays.asList(second.key, second.height));
+        res.add([second.key, second.height]);
+      first = first.next;
+      second = second.next;
+    }
+    return res;
+  }
+}
+
+class E {
+  // divide and conquer
+// Runtime: 498 ms, faster than 100.00% of Dart online submissions for The Skyline Problem.
+// Memory Usage: 152 MB, less than 100.00% of Dart online submissions for The Skyline Problem.
+
+  List<List<int>> getSkyline(List<List<int>> buildings) {
+    List<List<int>> res = [].map((e) => <int>[]).toList();
+    if (buildings.length == 0) return res;
+    int n = buildings.length;
+    return findSkyline(buildings, 0, n - 1);
+  }
+
+  List<List<int>> findSkyline(List<List<int>> buildings, int lo, int hi) {
+    List<List<int>> res = [].map((e) => <int>[]).toList();
+    ;
+    if (lo == hi) {
+      res.add([buildings[lo][0], buildings[lo][2]]);
+      res.add([buildings[lo][1], 0]);
+      return res;
+    }
+    int mid = lo + (hi - lo) ~/ 2;
+    List<List<int>> skyline1 = findSkyline(buildings, lo, mid);
+    List<List<int>> skyline2 = findSkyline(buildings, mid + 1, hi);
+    return mergeSkyline(skyline1, skyline2);
+  }
+
+  List<List<int>> mergeSkyline(
+      List<List<int>> skyline1, List<List<int>> skyline2) {
+    List<List<int>> res = [].map((e) => <int>[]).toList();
+    int i = 0, j = 0;
+    int h1 = 0, h2 = 0;
+
+    while (i < skyline1.length && j < skyline2.length) {
+      int x1 = skyline1.elementAt(i).elementAt(0);
+      int x2 = skyline2.elementAt(j).elementAt(0);
+      int x;
+      if (x1 < x2) {
+        h1 = skyline1.elementAt(i++).elementAt(1);
+        x = x1;
+      } else if (x1 > x2) {
+        h2 = skyline2.elementAt(j++).elementAt(1);
+        x = x2;
+      } else {
+        h1 = skyline1.elementAt(i++).elementAt(1);
+        h2 = skyline2.elementAt(j++).elementAt(1);
+        x = x1;
+      }
+      int h = max(h1, h2);
+
+      if (res.isEmpty || h != res.elementAt(res.length - 1).elementAt(1)) {
+        res.add([x, h]);
+      }
+    }
+
+    while (i < skyline1.length) res.add(skyline1.elementAt(i++));
+    while (j < skyline2.length) res.add(skyline2.elementAt(j++));
+
+    return res;
+  }
+}
+
+class F {
+// Runtime: 835 ms, faster than 100.00% of Dart online submissions for The Skyline Problem.
+// Memory Usage: 151.5 MB, less than 100.00% of Dart online submissions for The Skyline Problem.
+
+  List<List<int>> getSkyline(List<List<int>> buildings) {
+    if (buildings.length == 0) return [].map((e) => <int>[]).toList();
+    return recurSkyline(buildings, 0, buildings.length - 1);
+  }
+
+  List<List<int>> recurSkyline(List<List<int>> buildings, int p, int q) {
+    if (p < q) {
+      int mid = p + (q - p) ~/ 2;
+      return merge(
+          recurSkyline(buildings, p, mid), recurSkyline(buildings, mid + 1, q));
+    } else {
+      List<List<int>> rs = [].map((e) => <int>[]).toList();
+      rs.add([buildings[p][0], buildings[p][2]]);
+      rs.add([buildings[p][1], 0]);
+      return rs;
+    }
+  }
+
+  List<List<int>> merge(List<List<int>> l1, List<List<int>> l2) {
+    List<List<int>> rs = [].map((e) => <int>[]).toList();
+    int h1 = 0, h2 = 0;
+    while (l1.length > 0 && l2.length > 0) {
+      int x = 0, h = 0;
+      if (l1.first[0] < l2.first[0]) {
+        x = l1.first[0];
+        h1 = l1.first[1];
+        h = max(h1, h2);
+        // remove first
+        l1.removeAt(0);
+      } else if (l1.first[0] > l2.first[0]) {
+        x = l2.first[0];
+        h2 = l2.first[1];
+        h = max(h1, h2);
+        l2.removeAt(0);
+      } else {
+        x = l1.first[0];
+        h1 = l1.first[1];
+        h2 = l2.first[1];
+        h = max(h1, h2);
+        l1.removeAt(0);
+        l2.removeAt(0);
+      }
+      if (rs.length == 0 || h != rs.last[1]) {
+        rs.add([x, h]);
+      }
+    }
+    rs.addAll(l1);
+    rs.addAll(l2);
+    return rs;
+  }
+}
+
+extension Splice<T> on List<T> {
+  List<T> splice<T>(List<T> list, int index,
+      [num howMany = 0, /*<T | List<T>>*/ elements]) {
+    var endIndex = index + howMany.truncate();
+    list.removeRange(index, endIndex >= list.length ? list.length : endIndex);
+    if (elements != null)
+      list.insertAll(index, elements is List<T> ? elements : <T>[elements]);
+    return list;
+  }
+}