[Function add]

1. Add leetcode solutions with tag binary search.

Author: Seanforfun

README.md

@@ -319,7 +319,7 @@
 
 [173. Binary Search Tree Iterator](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/173.%20Binary%20Search%20Tree%20Iterator.md)
 
-[174. Dungeon Game](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/174.%20Dungeon20Game.md)
+[174. Dungeon Game](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/174.%20Dungeon%20Game.md)
 
 [175. Combine Two Tables](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/175.%20Combine%20Two%20Tables.md)
 

leetcode/4. Median of Two Sorted Arrays.md

@@ -107,4 +107,31 @@ class Solution {
             (double)merge[merge.length / 2] : (double)(merge[merge.length / 2] + merge[merge.length / 2 - 1]) / 2;
     }
 }
-```
+```
+
+### Third Time
+* Method 1: binary search
+	```Java
+	class Solution {
+		public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+			int m = nums1.length, n = nums2.length;
+			if(m > n) return findMedianSortedArrays(nums2, nums1);
+			int k = (m + n + 1) / 2;
+			int left = 0, right = m;
+			while(left < right){
+				int mid1 = left + (right - left) / 2;
+				int mid2 = k - mid1;
+				if(nums1[mid1] < nums2[mid2 - 1]) left = mid1 + 1;
+				else right = mid1;
+			}
+			int mid1 = left;
+			int mid2 = k - left;
+			int c1 = Math.max(mid1 <= 0 ? Integer.MIN_VALUE: nums1[mid1 - 1],
+							 mid2 <= 0 ? Integer.MIN_VALUE: nums2[mid2 - 1]);
+			if((m + n) % 2 != 0) return (double)c1;
+			int c2 = Math.min(mid1 >= m ? Integer.MAX_VALUE: nums1[mid1],
+							 mid2 >= n ? Integer.MAX_VALUE: nums2[mid2]);
+			return (c1 + c2) * 0.5;
+		}
+	}
+	```

leetcode/719. Find K-th Smallest Pair Distance.md

@@ -0,0 +1,70 @@
+## 719. Find K-th Smallest Pair Distance
+
+### Question:
+Given an integer array, return the k-th smallest distance among all the pairs. The distance of a pair (A, B) is defined as the absolute difference between A and B.
+
+```
+Example 1:
+
+Input:
+nums = [1,3,1]
+k = 1
+Output: 0 
+Explanation:
+Here are all the pairs:
+(1,3) -> 2
+(1,1) -> 0
+(3,1) -> 2
+Then the 1st smallest distance pair is (1,1), and its distance is 0.
+```
+
+Note:
+1. 2 <= len(nums) <= 10000.
+2. 0 <= nums[i] < 1000000.
+3. 1 <= k <= len(nums) * (len(nums) - 1) / 2.
+
+### Solution:
+* Method 1: Bucket sort
+    ```Java
+    class Solution {
+        public int smallestDistancePair(int[] nums, int k) {
+            int len = nums.length;
+            int size = len * (len - 1) / 2;
+            int[] arr = new int[1000000];
+            for(int i = 0; i < len; i++){
+                for(int j = i + 1; j < len; j++){
+                    arr[Math.abs(nums[i] - nums[j])]++;
+                }
+            }
+            int cur = 0;
+            while(k > 0){
+                k -= arr[cur++];
+            }
+            return cur - 1;
+        }
+    }
+    ```
+
+* Method 2: Binary Search + dp
+    ```Java
+    class Solution {
+        public int smallestDistancePair(int[] nums, int k) {
+            Arrays.sort(nums);
+            int len = nums.length;
+            int left = 0, right = nums[nums.length - 1];
+            while(left <= right){
+                int mid = left + (right - left) / 2;
+                int j = 0;
+                int count = 0;
+                for(int i = 0; i < len; i++){
+                    while(j < len && nums[j] - nums[i] <= mid) ++j;
+                    count += j - i - 1;
+                }
+                if(count >= k) right = mid - 1;
+                else left = mid + 1;
+            }
+            return left;
+        }
+    }
+    ```
+   

leetcode/778. Swim in Rising Water.md

@@ -72,3 +72,43 @@ Note:
       }
   }
   ```
+
+* Method 2: Binary Search
+	```Java
+	class Solution {
+		private int[][] g;
+		private int N;
+		private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
+		private boolean hasPath(int t){
+			if(g[0][0] > t) return false;
+			Queue<int[]> q = new LinkedList<>();
+			q.offer(new int[]{0, 0});
+			Set<Integer> seen = new HashSet<>();
+			seen.add(0);
+			while(!q.isEmpty()){
+				int[] cur = q.poll();
+				if(cur[0] == N - 1 && cur[1] == N - 1) return true;
+				int tx = 0, ty = 0;
+				for(int d = 0; d < 4; d++){
+					tx = cur[0] + dir[d][0];
+					ty = cur[1] + dir[d][1];
+					if(tx < 0 || tx >= N || ty < 0 || ty >= N || g[tx][ty] > t || seen.contains(tx * N + ty)) continue;
+					seen.add(tx * N + ty);
+					q.offer(new int[]{tx, ty});
+				}
+			}
+			return false;
+		}
+		public int swimInWater(int[][] grid) {
+			this.g = grid;
+			this.N = grid.length;
+			int left = 0, right = N * N;
+			while(left <= right){
+				int mid = left + (right - left) / 2;
+				if(hasPath(mid)) right = mid - 1;
+				else left = mid + 1;
+			}
+			return left;
+		}
+	}
+	```

leetcode/875. Koko Eating Bananas.md

@@ -0,0 +1,58 @@
+## 875. Koko Eating Bananas
+
+### Question:
+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:
+
+Input: piles = [3,6,7,11], H = 8
+Output: 4
+
+Example 2:
+
+Input: piles = [30,11,23,4,20], H = 5
+Output: 30
+
+Example 3:
+
+Input: piles = [30,11,23,4,20], H = 6
+Output: 23
+```
+
+Note:
+1. 1 <= piles.length <= 10^4
+2. piles.length <= H <= 10^9
+3. 1 <= piles[i] <= 10^9
+
+### Solution:
+* Method 1: Binary Search
+    ```Java
+    class Solution {
+        private int[] p;
+        private boolean canEat(int H, int K){
+            int res = 0;
+            for(int pp : p){
+                res += ((pp / K) + (((pp % K) == 0) ? 0: 1));
+            }
+            return res <= H;
+        }
+        public int minEatingSpeed(int[] piles, int H) {
+            this.p = piles;
+            int slow = 1, fast = 1000000000;
+            while(slow <= fast){
+                int mid = slow + (fast - slow) / 2;
+                if(canEat(H, mid)) fast = mid - 1;
+                else slow = mid + 1;
+            }
+            return slow;
+        }
+    }
+    ```
+