[Function add]:1. Add leetcode solutions with tag binary search.

Author: Botao Xiao

leetcode/378. Kth Smallest Element in a Sorted Matrix.md

@@ -0,0 +1,69 @@
+## 378. Kth Smallest Element in a Sorted Matrix
+
+### Question
+Given a n x n matrix where each of the rows and columns are sorted in ascending order, find the kth smallest element in the matrix.
+
+Note that it is the kth smallest element in the sorted order, not the kth distinct element.
+
+```
+Example:
+
+matrix = [
+   [ 1,  5,  9],
+   [10, 11, 13],
+   [12, 13, 15]
+],
+k = 8,
+
+return 13.
+```
+
+Note:
+1. You may assume k is always valid, 1 ≤ k ≤ n2.
+
+### Solution
+* Method 1: PriorityQueue O(NlgN + K)
+  ```Java
+  class Solution {
+      public int kthSmallest(int[][] matrix, int k) {
+          PriorityQueue<Integer> pq = new PriorityQueue<>();
+          for(int[] mat : matrix)
+              for(int m : mat)
+                  pq.offer(m);
+          while(--k != 0)
+              pq.poll();
+          return pq.peek();
+      }
+  }
+  ```
+
+* Method 2: binary search
+  ```Java
+  class Solution {
+      public int kthSmallest(int[][] matrix, int k) {
+          int n = matrix.length;
+          int low = matrix[0][0], high = matrix[n - 1][n - 1];
+          while(low <= high){
+              int mid = low + (high - low) / 2;
+              int count = getLowerNum(matrix, mid);
+              if(count < k) low = mid + 1;
+              else high = mid - 1;
+          }
+          return low;
+      }
+      private int getLowerNum(int[][] matrix, int num){
+          int n = matrix.length;
+          int row = n - 1, col = 0;
+          int res = 0;
+          while(row >= 0 && col < n){
+              if(matrix[row][col] > num)
+                  row--;
+              else{
+                  res += row + 1;
+                  col++;
+              }
+          }
+          return res;
+      }
+  }
+  ```

leetcode/429. N-ary Tree Level Order Traversal.md

@@ -0,0 +1,61 @@
+## 668. Kth Smallest Number in Multiplication Table
+
+### Question
+Nearly every one have used the Multiplication Table. But could you find out the k-th smallest number quickly from the multiplication table?
+
+Given the height m and the length n of a m * n Multiplication Table, and a positive integer k, you need to return the k-th smallest number in this table.
+
+```
+Example 1:
+Input: m = 3, n = 3, k = 5
+Output:
+Explanation:
+The Multiplication Table:
+1	2	3
+2	4	6
+3	6	9
+
+The 5-th smallest number is 3 (1, 2, 2, 3, 3).
+Example 2:
+Input: m = 2, n = 3, k = 6
+Output:
+Explanation:
+The Multiplication Table:
+1	2	3
+2	4	6
+
+The 6-th smallest number is 6 (1, 2, 2, 3, 4, 6).
+```
+
+Note:
+1. The m and n will be in the range [1, 30000].
+2. The k will be in the range [1, m * n]
+
+### Solution
+* Method 1: binary search
+  ```Java
+  class Solution {
+      public int findKthNumber(int m, int n, int k) {
+         int low = 1, high = m * n;
+          while(low <= high){
+              int mid = low + (high - low) / 2;
+              int count = getLowerNum(m, n, mid);
+              if(count < k) low = mid + 1;
+              else high = mid - 1;
+          }
+          return low;
+      }
+      private int getLowerNum(int m, int n, int target){
+          int row = m - 1, col = 0;
+          int res = 0;
+          while(row >= 0 && col < n){
+              if((row + 1) * (col + 1) > target) row--;
+              else{
+                  res += row + 1;
+                  col++;
+              }
+          }
+          return res;
+      }
+  }
+  ```

leetcode/437. Path Sum III.md

@@ -0,0 +1,74 @@
+## 778. Swim in Rising Water
+
+### Question
+On an N x N grid, each square grid[i][j] represents the elevation at that point (i,j).
+
+Now rain starts to fall. At time t, the depth of the water everywhere is t. You can swim from a square to another 4-directionally adjacent square if and only if the elevation of both squares individually are at most t. You can swim infinite distance in zero time. Of course, you must stay within the boundaries of the grid during your swim.
+
+You start at the top left square (0, 0). What is the least time until you can reach the bottom right square (N-1, N-1)?
+
+```
+Example 1:
+
+Input: [[0,2],[1,3]]
+Output: 3
+Explanation:
+At time 0, you are in grid location (0, 0).
+You cannot go anywhere else because 4-directionally adjacent neighbors have a higher elevation than t = 0.
+
+You cannot reach point (1, 1) until time 3.
+When the depth of water is 3, we can swim anywhere inside the grid.
+Example 2:
+
+Input: [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
+Output: 16
+Explanation:
+ 0  1  2  3  4
+24 23 22 21  5
+12 13 14 15 16
+11 17 18 19 20
+10  9  8  7  6
+
+The final route is marked in bold.
+We need to wait until time 16 so that (0, 0) and (4, 4) are connected.
+```
+
+Note:
+1. 2 <= N <= 50.
+2. grid[i][j] is a permutation of [0, ..., N*N - 1].
+
+### Solutions:
+* Method 1: Dijkstra O(n^2NlgN)
+  ```Java
+  class Solution {
+      private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+      public int swimInWater(int[][] grid) {
+          PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
+              @Override
+              public int compare(int[] a, int[] b){
+                  return a[0] - b[0];
+              }
+          });
+          int n = grid.length;
+          pq.offer(new int[]{grid[0][0], 0});
+          Set<Integer> seen = new HashSet<>();
+          seen.add(0);
+          while(!pq.isEmpty()){
+              int[] node = pq.poll();
+              int t = node[0];
+              int row = node[1] / n;
+              int col = node[1] % n;
+              if(row == n - 1 && col == n - 1) return t;
+              int tx = 0, ty = 0;
+              for(int d = 0; d < 4; d++){
+                  tx = row + dir[d][0];
+                  ty = col + dir[d][1];
+                  if(seen.contains(tx * n + ty) || tx < 0 || tx >= n || ty < 0 || ty >= n) continue;
+                  seen.add(tx * n + ty);
+                  pq.offer(new int[]{Math.max(t, grid[tx][ty]), tx * n + ty});
+              }
+          }
+          return -1;
+      }
+  }
+  ```