finish 74,75,240

Author: BaffinLee

001-100/74. Search a 2D Matrix.md

@@ -0,0 +1,126 @@
+# 74. Search a 2D Matrix
+
+- Difficulty: Medium.
+- Related Topics: Array, Binary Search.
+- Similar Questions: Search a 2D Matrix II.
+
+## Problem
+
+Write an efficient algorithm that searches for a value in an **m** x **n** matrix. This matrix has the following properties:
+
+- Integers in each row are sorted from left to right.
+- The first integer of each row is greater than the last integer of the previous row.
+
+**Example 1:**
+
+```
+Input:
+matrix = [
+  [1,   3,  5,  7],
+  [10, 11, 16, 20],
+  [23, 30, 34, 50]
+]
+target = 3
+Output: true
+```
+
+**Example 2:**
+
+```
+Input:
+matrix = [
+  [1,   3,  5,  7],
+  [10, 11, 16, 20],
+  [23, 30, 34, 50]
+]
+target = 13
+Output: false
+```
+
+## Solution 1
+
+```javascript
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function(matrix, target) {
+  var row = searchRow(matrix, target, 0, matrix.length - 1);
+  return row === -1 ? false : searchArray(matrix[row], target, 0, matrix[row].length - 1);
+};
+
+var searchRow = function (matrix, target, top, bottom) {
+  if (top > bottom) return -1;
+  var mid = top + Math.floor((bottom - top) / 2);
+  var len = matrix[mid].length;
+  if (len === 0) return -1;
+  if (matrix[mid][0] <= target && target <= matrix[mid][len - 1]) {
+    return mid;
+  } else if (target < matrix[mid][0]) {
+    return searchRow(matrix, target, top, mid - 1);
+  } else {
+    return searchRow(matrix, target, mid + 1, bottom);
+  }
+};
+
+var searchArray = function (arr, target, left, right) {
+  if (left > right) return false;
+  var mid = left + Math.floor((right - left) / 2);
+  if (arr[mid] === target) {
+    return true;
+  } else if (arr[mid] > target) {
+    return searchArray(arr, target, left, mid - 1);
+  } else {
+    return searchArray(arr, target, mid + 1, right);
+  }
+};
+```
+
+**Explain:**
+
+先找行，再找列。
+
+**Complexity:**
+
+* Time complexity : O(log(m) + log(n)). ```n``` 行 ```m``` 列。
+* Space complexity : O(1).
+
+## Solution 2
+
+```javascript
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function(matrix, target) {
+  var n = matrix.length;
+  var m = (matrix[0] || []).length;
+  var ll = 0;
+  var rr = (n * m) - 1;
+  var mid = 0;
+  var tmp = 0;
+  while (ll <= rr) {
+    mid = ll + Math.floor((rr - ll) / 2);
+    tmp = matrix[Math.floor(mid / m)][mid % m];
+    if (tmp === target) {
+      return true;
+    } else if (tmp > target) {
+      rr = mid - 1;
+    } else {
+      ll = mid + 1;
+    }
+  }
+  return false;
+};
+```
+
+**Explain:**
+
+直接找位置。
+
+**Complexity:**
+
+* Time complexity : O(log(m*n)). ```n``` 行 ```m``` 列。
+* Space complexity : O(1).

001-100/75. Sort Colors.md

@@ -0,0 +1,124 @@
+# 75. Sort Colors
+
+- Difficulty: Medium.
+- Related Topics: Array, Two Pointers, Sort.
+- Similar Questions: Sort List, Wiggle Sort, Wiggle Sort II.
+
+## Problem
+
+Given an array with **n** objects colored red, white or blue, sort them **in-place **so that objects of the same color are adjacent, with the colors in the order red, white and blue.
+
+Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
+
+**Note:** You are not suppose to use the library's sort function for this problem.
+
+**Example:**
+
+```
+Input: [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
+```
+
+**Follow up:**
+
+
+- A rather straight forward solution is a two-pass algorithm using counting sort. First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.
+- Could you come up with a one-pass algorithm using only constant space?
+
+## Solution 1
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var sortColors = function(nums) {
+  var counts = [0, 0, 0];
+  var len = nums.length;
+  for (var i = 0; i < len; i++) {
+    counts[nums[i]]++;
+  }
+  for (var j = 0; j < len; j++) {
+    nums[j] = j < counts[0] ? 0 : (j < counts[0] + counts[1] ? 1 : 2);
+  }
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(2n).
+* Space complexity : O(1).
+
+## Solution 2
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var sortColors = function(nums) {
+  var m = 0;
+  var n = 0;
+  var k = nums.length;
+  for (var i = 0; i < k; i++) {
+    if (nums[i] === 0) {
+      nums[i] = 2;
+      nums[n++] = 1;
+      nums[m++] = 0;
+    } else if (nums[i] === 1) {
+      nums[i] = 2;
+      nums[n++] = 1;
+    } else {
+      nums[i] = 2;
+    }
+  }
+};
+```
+
+**Explain:**
+
+`[0, m)` 是 `0`，`[m, n)` 是 `1`，`[n, k)` 是 `2`。
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).
+
+## Solution 3
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+var sortColors = function(nums) {
+  var j = 0;
+  var k = nums.length - 1;
+  for (var i = 0; i <= k; i++) {
+    if (nums[i] === 0) {
+      swap(nums, i, j++);
+    } else if (nums[i] === 2) {
+      swap(nums, i--, k--);
+    }
+  }
+};
+
+var swap = function (arr, a, b) {
+  var tmp = arr[a];
+  arr[a] = arr[b];
+  arr[b] = tmp;
+};
+```
+
+**Explain:**
+
+`[0, j)` 是 `0`，`[j, k)` 是 `1`，`[k, len)` 是 `2`。
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

201-300/240. Search a 2D Matrix II.md

@@ -0,0 +1,75 @@
+# 240. Search a 2D Matrix II
+
+- Difficulty: Medium.
+- Related Topics: Binary Search, Divide and Conquer.
+- Similar Questions: Search a 2D Matrix.
+
+## Problem
+
+Write an efficient algorithm that searches for a value in an *m* x *n* matrix. This matrix has the following properties:
+
+- Integers in each row are sorted in ascending from left to right.
+- Integers in each column are sorted in ascending from top to bottom.
+
+Consider the following matrix:
+
+```
+[
+  [1,   4,  7, 11, 15],
+  [2,   5,  8, 12, 19],
+  [3,   6,  9, 16, 22],
+  [10, 13, 14, 17, 24],
+  [18, 21, 23, 26, 30]
+]
+```
+
+**Example 1:**
+
+```
+Input: matrix, target = 5
+Output: true
+```
+
+**Example 2:**
+
+```
+Input: matrix, target = 20
+Output: false
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function(matrix, target) {
+  var n = matrix.length;
+  var m = (matrix[0] || []).length;
+  var x = m - 1;
+  var y = 0;
+  var tmp = 0;
+  while (x >= 0 && y < n) {
+    tmp = matrix[y][x];
+    if (target === tmp) {
+      return true;
+    } else if (target > tmp) {
+      y++;
+    } else {
+      x--;
+    }
+  }
+  return false;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n + m). ```n``` 行 ```m``` 列。
+* Space complexity : O(1).