Merge pull request chipbk10#123 from chipbk10/BinarySearch

Binary search

Author: chipbk10

src/binarysearch/Problem1011_CapacityToShipPackagesWithinDDays.java

@@ -0,0 +1,25 @@
+package binarysearch;
+
+public class Problem1011_CapacityToShipPackagesWithinDDays {
+
+    public int shipWithinDays(int[] weights, int D) {
+        int lo = 0, hi = 0;
+        for (int w: weights) {
+            lo = Math.max(lo, w);
+            hi += w;
+        }
+        while (lo <= hi) {
+            int mid = lo + (hi-lo) / 2, need = 1, cur = 0;
+            for (int w: weights) {
+                if (cur + w > mid) {
+                    need += 1;
+                    cur = 0;
+                }
+                cur += w;
+            }
+            if (need <= D) hi = mid - 1;
+            else lo = mid+1;
+        }
+        return lo;
+    }
+}

src/binarysearch/Problem410_SplitArrayLargestSum.java

@@ -0,0 +1,36 @@
+package binarysearch;
+
+public class Problem410_SplitArrayLargestSum {
+
+    public int splitArray(int[] A, int m) {
+        int max = 0; long sum = 0;
+        for (int a : A) {
+            max = Math.max(max, a);
+            sum += a;
+        }
+
+        if (m == 1) return (int)sum;
+
+        long lo = max, hi = sum;
+        while (lo <= hi) {
+            long mid = (lo+hi)/2;
+            if (isValid(A, m, mid)) hi = mid-1;
+            else lo = mid+1;
+        }
+
+        return (int)lo;
+    }
+
+    private boolean isValid(int[] A, int m, long max) {
+        int sum = 0, count = 1;
+        for (int a : A) {
+            sum += a;
+            if (sum > max) {
+                sum = a;
+                count++;
+                if (count > m) return false;
+            }
+        }
+        return true;
+    }
+}

src/binarysearch/Problem875_KokoEatingBananas.java

@@ -0,0 +1,42 @@
+package binarysearch;
+
+public class Problem875_KokoEatingBananas {
+
+    public int minEatingSpeed(int[] piles, int H) {
+        // min(K) : eat all piles & times <= H
+        // [3,6,7,11]
+        // K = 11 -> 4 hours
+        // K = 8 -> 5 hours
+        // K = 6 -> 1 + 1 + 2 + 2 = 6 hours
+        // K = 5 -> 1 + 2 + 2 + 3 = 8 hours
+        // K = 4 -> 1 + 2 + 2 + 3 = 8 hours
+        // K = 3 -> 1 + 2 + 3 + 4 > 8 hours
+
+        // lo = 1, hi = max;
+        // function(mid) <= H --> hi = mid-1
+        // function(mid) > H --> lo = mid+1
+        // return lo
+
+        int lo = 1, hi = 0;
+        for (int pile: piles) hi = Math.max(hi, pile);
+
+        while (lo <= hi) {
+            int mid = lo + (hi-lo)/2;
+            if (timeToEatAll(piles, mid) <= H) hi = mid-1;
+            else lo = mid+1;
+        }
+        return lo;
+    }
+
+    private int timeToEatAll(int[] piles, int speed) {
+        int res = 0;
+        for (int pile : piles) {
+            if (speed >= pile) res += 1;
+            else {
+                res += pile/speed;
+                if (pile%speed != 0) res++;
+            }
+        }
+        return res;
+    }
+}

src/binarysearch/ReadMe.java

@@ -2,53 +2,43 @@
 
 public class ReadMe {
 
-    /**
-     * summary of 2 most frequently used binary search templates.
-     * one is return index during the search:
-     *
-     * while lo <= hi:
-     *   mid = (lo+hi)/2
-     *   if nums[mid] == target:
-     *     return mid
-     *   if nums[mid] > target:
-     *     hi = mid-1
-     *   else:
-     *     lo = mid+1
-     * return -1
-     *
-     * Another more frequently used binary search template is for searching lowest element
-     * satisfy function(i) == True (the array should satisfy function(x) == False for 0 to i-1,
-     * and function(x) == True for i to n-1, and it is up to the question to define the function,
-     * like in the find peak element problem, function(x) can be nums[x] < nums[x+1] ),
-     * there are 2 ways to write it:
-     *
-     * while lo <= hi:
-     *   mid = (lo+hi)/2
-     *   if function(mid):
-     *     hi = mid-1
-     *   else:
-     *     lo = mid+1
-     * return lo
-     *
-     * or
-     *
-     * while lo <  hi:
-     *   mid = (lo+hi)/2
-     *   if function(mid):
-     *     hi = mid
-     *   else:
-     *     lo = mid+1
-     *
-     * return lo ---> lowest element that satifies function(x)
-     * return hi ---> highest element that not satifies function(x)
-     *
-     * No matter which one you use, just be careful about updating the hi and lo,
-     * which could easily lead to infinite loop.
-     * Some binary question is searching a floating number
-     * and normally the question will give you a precision,
-     * in which case you don't need to worry too much about the infinite loop
-     * but your while condition will become something like "while lo+1e-7<hi"
-     *
+    /*
+        |--x-----x------[v]vvvvvvvvvvvvvvvv|
+        while (lo <= hi) {
+            int mid = lo + (hi-lo)/2;
+            if function(mid)
+                hi = mid-1;
+            else
+                lo = mid+1;
+        }
+        return lo; ---> lowest element that satisfies function(x)
+
+        |vvvvvvvvvvvvv[v]-----x------x-------|
+        while (lo <= hi) {
+            int mid = lo + (hi-lo)/2;
+            if function(mid)
+                lo = mid+1;
+            else
+                hi = mid-1;
+        }
+        return hi; ---> highest element that satisfies function(x)
+
+        |----x----[v]----------x--------------|
+        while (lo <= hi) {
+            int mid = lo + (hi-lo)/2;
+            if function(mid) == target
+                return mid;
+            if function(mid) < target
+                lo = mid+1;
+            else
+                hi = mid-1;
+        }
+        return -1;
+
+        Note: function(x) is non-decreasing function
+     */
+
+     /*
      *
      * Collections.binarySearch
      * Array.binarySearch