GitBook: [master] 6 pages modified

Author: just4once

SUMMARY.md

@@ -261,6 +261,10 @@
     * [774-minimize-max-distance-to-gas-station](leetcode/binary-search/774-minimize-max-distance-to-gas-station.md)
     * [778-swim-in-rising-water](leetcode/binary-search/778-swim-in-rising-water.md)
     * [786-k-th-smallest-prime-fraction](leetcode/binary-search/untitled.md)
+    * [793-preimage-size-of-factorial-zeroes-function](leetcode/binary-search/793-preimage-size-of-factorial-zeroes-function.md)
+    * [852-peak-index-in-a-mountain-array](leetcode/binary-search/852-peak-index-in-a-mountain-array.md)
+    * [862-shortest-subarray-with-sum-at-least-k](leetcode/binary-search/862-shortest-subarray-with-sum-at-least-k.md)
+    * [875-koko-eating-bananas](leetcode/binary-search/875-koko-eating-bananas.md)
   * [dynamic-programing](leetcode/dynamic-programing/README.md)
     * [174-dungeon-game](leetcode/dynamic-programing/174-dungeon-game.md)
   * [bit-manipulation](leetcode/bit-manipulation-1/README.md)

leetcode/binary-search/793-preimage-size-of-factorial-zeroes-function.md

@@ -0,0 +1,72 @@
+# 793-preimage-size-of-factorial-zeroes-function
+
+## Question {#question}
+
+[https://leetcode.com/problems/preimage-size-of-factorial-zeroes-function/description/](https://leetcode.com/problems/preimage-size-of-factorial-zeroes-function/description/)
+
+Let f\(x\) be the number of zeroes at the end of x!. \(Recall that x! = 1  _2_  3  _..._  x, and by convention, 0! = 1.\)
+
+For example, f\(3\) = 0 because 3! = 6 has no zeroes at the end, while f\(11\) = 2 because 11! = 39916800 has 2 zeroes at the end. Given K, find how many non-negative integers x have the property that f\(x\) = K.
+
+**Example:**
+
+```text
+Example 1:
+Input: K = 0
+Output: 5
+Explanation: 0!, 1!, 2!, 3!, and 4! end with K = 0 zeroes.
+
+Example 2:
+Input: K = 5
+Output: 0
+Explanation: There is no x such that x! ends in K = 5 zeroes.
+```
+
+**Note:**
+
+K will be an integer in the range \[0, 10^9\].
+
+## Thought Process {#thought-process}
+
+1. Binary Search
+   1. The number of trailing zeroes increase every time we have multiplication result of 10, meaning factor of 5 and 2
+   2. So, the number of zeroes = min\(num of 2's, num of 5's\), and because of factor 2 appear at least every other number, we can simply count the number of factor 5
+   3. For each x, K <= x < 5K + 1
+   4. Performing binary search on this borders until the borders meet
+   5. If we have found a value where we have exactly K zeroes, we can return 5
+   6. Else there is no possible way to have K zeroes we return 0
+   7. Time complexity O\(logK\)
+   8. Space complexity O\(1\)
+
+## Solution
+
+```java
+class Solution {
+    public int preimageSizeFZF(int K) {
+        // x / 5 <= f(x) <= x
+        // so x >= K && x <= 5K
+        // Therefore x will in the range of [K, ]
+        long lo = K, hi = 5L * K + 1;
+        while (lo < hi) {
+            long mi = lo + (hi - lo) / 2;
+            int k = f(mi);
+            if (k == K) return 5;
+            else if (k < K) lo = mi + 1;
+            else hi = mi - 1;
+        }
+        return 0;
+    }
+    
+    private int f(long x) {
+        int count = 0;
+        while (x > 0) {
+            x /= 5;
+            count += x;
+        }
+        return count;
+    }
+}
+```
+
+## Additional {#additional}
+

leetcode/binary-search/852-peak-index-in-a-mountain-array.md

@@ -0,0 +1,53 @@
+# 852-peak-index-in-a-mountain-array
+
+## Question {#question}
+
+[https://leetcode.com/problems/peak-index-in-a-mountain-array/description/](https://leetcode.com/problems/peak-index-in-a-mountain-array/description/)
+
+Let's call an array A a mountain if the following properties hold:
+
+A.length >= 3 There exists some 0 < i < A.length - 1 such that A\[0\] < A\[1\] < ... A\[i-1\] < A\[i\] > A\[i+1\] > ... > A\[A.length - 1\] Given an array that is definitely a mountain, return any i such that A\[0\] < A\[1\] < ... A\[i-1\] < A\[i\] > A\[i+1\] > ... > A\[A.length - 1\].
+
+**Example:**
+
+```text
+Input: [0,1,0]
+Output: 1
+
+Input: [0,2,1,0]
+Output: 1
+```
+
+**Note:**
+
+3 <= A.length <= 10000 0 <= A\[i\] <= 10^6 A is a mountain, as defined above.
+
+## Thought Process {#thought-process}
+
+1. Binary Search
+   1. Since there is only one peak, we can use binary search to successively cut the search range by half
+   2. The boundaries are lo = 1, hi = A.length - 2
+   3. We compare A\[mi\] to A\[mi + 1\]
+   4. If A\[mi\] < A\[mi + 1\], the peak lies on the right, so lo = mi + 1
+   5. Else hi = mi
+   6. Time complexity O\(logn\)
+   7. Space complexity O\(1\)
+
+## Solution
+
+```java
+class Solution {
+    public int peakIndexInMountainArray(int[] A) {
+        int lo = 1, hi = A.length - 2;
+        while (lo < hi) {
+            int mi = lo + (hi - lo) / 2;
+            if (A[mi] < A[mi + 1]) lo = mi + 1;
+            else hi = mi;
+        }
+        return lo;
+    }
+}
+```
+
+## Additional {#additional}
+

leetcode/binary-search/862-shortest-subarray-with-sum-at-least-k.md

@@ -0,0 +1,73 @@
+# 862-shortest-subarray-with-sum-at-least-k
+
+## Question {#question}
+
+[https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/description/](https://leetcode.com/problems/shortest-subarray-with-sum-at-least-k/description/)
+
+Return the length of the shortest, non-empty, contiguous subarray of A with sum at least K.
+
+If there is no non-empty subarray with sum at least K, return -1.
+
+**Example 1:**
+
+```text
+Input: A = [1], K = 1
+Output: 1
+```
+
+**Example 2:**
+
+```text
+Input: A = [1,2], K = 4
+Output: -1
+```
+
+**Example 3:**
+
+```text
+Input: A = [2,-1,2], K = 3
+Output: 3
+```
+
+**Note:**
+
+* 1 <= A.length <= 50000
+* -10 ^ 5 <= A\[i\] <= 10 ^ 5
+* 1 <= K <= 10 ^ 9
+
+## Thought Process {#thought-process}
+
+1. Deque
+   1. This problem can be rephrased as prefix sums of A, let's call it P
+   2. For every index j, we are trying to find largest i such that P\[j\] - P\[i\] >= K
+   3. If we check all the prefix sums before j, the run time will become n^2
+   4. For every j we visited, we add it to queue as potential answer for next j, let's define Q\[0\] to be the 1st item and Q\[1\] to be 2nd item and the rest follows the same pattern
+   5. For current j, we compare P\[j\] to P\[Q\[0\]\] and check if their difference >= K
+   6. If the difference is >= K, we can pop the first item because the in the next iteration, the length of using the first item will not be any better than current length
+   7. Another observation is that if P\[j\] is <= P\[Q\[last\]\], it's a better candidate than the last deque element, therefore we use while loop to removeLast
+   8. Essentially, we are maintaining a increasing P\[i\] in the deque
+   9. Time complexity O\(n\)
+   10. Space complexity O\(n\) 
+
+## Solution
+
+```java
+class Solution {
+    public int shortestSubarray(int[] A, int K) {
+        int n = A.length;
+        int[] P = new int[n + 1];
+        for(int i = 1; i < P.length; i++) P[i] = P[i - 1] + A[i - 1];
+        Deque<Integer> deque = new LinkedList<>();
+        int res = n + 1;
+        for (int j = 0; j < P.length; j++) {
+            while (!deque.isEmpty() && P[j] - P[deque.getFirst()] >= K) res = Math.min(res, j - deque.removeFirst());
+            while (!deque.isEmpty() && P[j] <= P[deque.getLast()]) deque.pollLast();
+            deque.offer(j);
+        }
+        return res == n + 1 ? - 1 : res;
+    }
+}
+```
+
+## Additional {#additional}
+

leetcode/binary-search/875-koko-eating-bananas.md

@@ -0,0 +1,103 @@
+# 875-koko-eating-bananas
+
+## Question {#question}
+
+\*\*\*\*[**https://leetcode.com/problems/koko-eating-bananas/description/**](https://leetcode.com/problems/koko-eating-bananas/description/)\*\*\*\*
+
+Koko loves to eat bananas.  There are `N` piles of bananas, the `i`-th pile has `piles[i]` bananas.  The guards have gone and will come back in `H` hours.
+
+Koko can decide her bananas-per-hour eating speed of `K`.  Each hour, she chooses some pile of bananas, and eats K bananas from that pile.  If the pile has less than `K` bananas, she eats all of them instead, and won't eat any more bananas during this hour.
+
+Koko likes to eat slowly, but still wants to finish eating all the bananas before the guards come back.
+
+Return the minimum integer `K` such that she can eat all the bananas within `H` hours.
+
+* 
+**Example 1:**
+
+```text
+Input: piles = [3,6,7,11], H = 8
+Output: 4
+```
+
+**Example 2:**
+
+```text
+Input: piles = [30,11,23,4,20], H = 5
+Output: 30
+```
+
+**Example 3:**
+
+```text
+Input: piles = [30,11,23,4,20], H = 6
+Output: 23
+```
+
+**Note:**
+
+* `1 <= piles.length <= 10^4`
+* `piles.length <= H <= 10^9`
+* `1 <= piles[i] <= 10^9`
+
+## Thought Process {#thought-process}
+
+1. Binary Search
+   1. Since the time is bounded by 1 and 10e9, we can successively half our search, lo and hi respectively
+   2. When the function canFinish\(mi\), we set our hi = mi, else we can increase our speed, so lo = mi + 1
+   3. Time complexity O\(nlog\(w\)\), where w is the range and n is number of elements
+   4. Space complexity O\(1\)
+2. Search Starts from Average Speed
+   1. Instead of making guess, we can smartly guess our initial value to be sum / H
+   2. If the speed is not enough, we can increase speed by 1 until Koko can finish it
+   3. Time complexity O\(n\)
+   4. Space complexity O\(1\)
+
+## Solution
+
+```java
+class Solution {
+    public int minEatingSpeed(int[] piles, int H) {
+        int lo = 1, hi = 1000000000;
+        while (lo < hi) {
+            int mi = lo + (hi - lo) / 2;
+            if (canFinish(piles, mi, H)) hi = mi;
+            else lo = mi + 1;
+        }
+        return lo;
+    }
+    
+    private boolean canFinish(int[] piles, int K, int H) {
+        int hour = 0;
+        for (int pile : piles) {
+            hour += (pile - 1) / K + 1;
+        }
+        return hour <= H;
+    }
+}
+```
+
+```java
+class Solution {
+    public int minEatingSpeed(int[] piles, int H) {
+        long sum = 0;
+        for (int pile : piles) sum += pile;
+        long speed = (sum - 1) / H + 1L;
+        while (true) {
+            if (canFinish(piles, speed, H)) return (int) speed;
+            else speed++;
+        }
+    }
+    
+    private boolean canFinish(int[] piles, long K, int H) {
+        int hour = 0;
+        for (int pile : piles) {
+            hour += (pile - 1) / K + 1;
+        }
+        return hour <= H;
+    }
+}
+```
+
+## Additional {#additional}
+

leetcode/binary-search/untitled.md

@@ -2,6 +2,8 @@
 
 ## Question {#question}
 
+[https://leetcode.com/problems/k-th-smallest-prime-fraction/description/](https://leetcode.com/problems/k-th-smallest-prime-fraction/description/)
+
 A sorted list A contains 1, plus some number of primes. Then, for every p < q in the list, we consider the fraction p/q.
 
 What is the K-th smallest fraction considered? Return your answer as an array of ints, where answer\[0\] = p and answer\[1\] = q.