solves #452: Minimum Number of Arrows to Burst Balloons in java

Author: anishLearnsToCode

README.md

@@ -315,6 +315,7 @@
 | 443  | [String Compression](https://leetcode.com/problems/string-compression)                                                                                                 |                                                       [![Java](assets/java.png)](src/StringCompression.java) [![Python](assets/python.png)](python/string_compression.py)                                                        |                                                                                                                                   |
 | 447  | [Number of Boomerangs](https://leetcode.com/problems/number-of-boomerangs)                                                                                             |                                                      [![Java](assets/java.png)](src/NumberOfBoomerangs.java) [![Python](assets/python.png)](python/number_of_boomerangs.py)                                                      |                                                                                                                                   |
 | 448  | [Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array)                                                     |                                    [![Java](assets/java.png)](src/FindAllNumbersDisappearedInAnArray.java) [![Python](assets/python.png)](python/find_all_numbers_disappeared_in_an_array.py)                                    |                                                                                                                                   |
+| 452  | [Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons)                                                 |                                                                            [![Java](assets/java.png)](src/MinimumNumberOfArrowsToBurstBalloons.java)                                                                             |                                                                                                                                   |
 | 453  | [Minimum Moves to Equal Array Elements](https://leetcode.com/problems/minimum-moves-to-equal-array-elements)                                                           |                                       [![Java](assets/java.png)](src/MinimumMovesToEqualArrayElements.java) [![Python](assets/python.png)](python/minimum_moves_to_equal_array_element.py)                                       |                                                                                                                                   |
 | 455  | [Assign Cookies](https://leetcode.com/problems/assign-cookies)                                                                                                         |                                                           [![Java](assets/java.png)](src/AssignCookies.java) [![Python](assets/python.png)](python/assign_cookies.py)                                                            |                                                                                                                                   |
 | 459  | [Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern)                                                                                 |                                                [![Java](assets/java.png)](src/RepeatedSubstringPattern.java) [![Python](assets/python.png)](python/repeated_substring_pattern.py)                                                |                                                                                                                                   |

src/HelloWorld.java

@@ -1,35 +1,80 @@
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 
 public class HelloWorld {
-    public int lengthOfLongestSubstring(String s) {
-        if (s.isEmpty()) {
-            return 0;
+    public static int[][] insert(int[][] intervals, int[] newInterval) {
+        if (intervals.length == 0) {
+            return new int[][] { newInterval };
         }
 
-        int maxLength = 1;
-        final Set<Character> slidingWindow = new HashSet<>() {{
-            add(s.charAt(0));
-        }};
+        final int startIndex = binarySearch(intervals, newInterval[0]);
 
-        for (int left = 0, right = 1, currentLength = 1 ; right < s.length() ; ) {
-            if (slidingWindow.contains(s.charAt(right))) {
-                slidingWindow.remove(s.charAt(left));
-                left++;
-                currentLength--;
+        final List<int[]> result = new ArrayList<>();
+        for (int i = 0 ; i < startIndex ; i++) {
+            result.add(intervals[i]);
+        }
+        result.add(newInterval);
+        for (int i = startIndex ; i < intervals.length ; i++) {
+            result.add(intervals[i]);
+        }
+
+        return mergeIntervals(result);
+    }
+
+    private static int[][] mergeIntervals(List<int[]> intervals) {
+        final List<int[]> result = new ArrayList<>();
+        int start = intervals.getFirst()[0], end = intervals.getFirst()[1];
+        for (int[] interval : intervals) {
+            if (interval[0] <= end) {
+                end = Math.max(interval[1], end);
             } else {
-                slidingWindow.add(s.charAt(right));
-                currentLength++;
-                maxLength = Math.max(maxLength, currentLength);
-                right++;
+                result.add(new int[]{start, end});
+                start = interval[0];
+                end = interval[1];
             }
         }
+        result.add(new int[] { start, end });
+        return toArray(result);
+    }
+
+    private static int binarySearch(int[][] intervals, int x) {
+        int left = 0, right = intervals.length - 1, middle;
+        while (left <= right) {
+            middle = left + (right - left) / 2;
+            if (intervals[middle][0] == x) return middle;
+            else if (intervals[middle][0] < x) left = middle + 1;
+            else right = middle - 1;
+        }
+        return left;
+    }
+
+    private static int[][] toArray(List<int[]> intervals) {
+        final int[][] result = new int[intervals.size()][2];
+        int k = 0;
+        for (int[] interval : intervals) {
+            result[k++] = interval;
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+//        System.out.println(Arrays.deepToString(
+//                insert(new int[][]{{1, 3}, {6, 9}}, new int[] {2, 5})
+//        ));
 
+//        System.out.println(Arrays.deepToString(
+//                insert(
+//                        new int[][] {{1, 2}, {3, 5}, {6, 7}, {8, 10}, {12, 16}},
+//                        new int[] {4, 8}
+//                )
+//        ));
 
-        return maxLength;
+        System.out.println(Arrays.deepToString(
+                insert(
+                        new int[][] {{1, 3}, {6, 9}},
+                        new int[] {2, 5}
+                )
+        ));
     }
 }

src/MinimumNumberOfArrowsToBurstBalloons.java

@@ -0,0 +1,26 @@
+// https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons
+// T: O(NlogN)
+// S: O(logN)
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class MinimumNumberOfArrowsToBurstBalloons {
+    public int findMinArrowShots(int[][] points) {
+        if (points.length == 0) {
+            return 0;
+        }
+
+        Arrays.sort(points, Comparator.comparingInt(o -> o[1]));
+
+        int arrows = 1, endPoint = points[0][1];
+        for (int[] p: points) {
+            if (endPoint < p[0]) {
+                arrows++;
+                endPoint = p[1];
+            }
+        }
+
+        return arrows;
+    }
+}