Merge branch 'master' of https://github.com/azl397985856/leetcode

Author: lucifer

daily/2019-07-26.md

@@ -14,7 +14,7 @@
 
 这是数据压缩问题中的一种。
 
-类似的问题有， 如果将 IP 地址用 4 个字节来表示等等。
+类似的问题有， 如何将 IP 地址用 4 个字节来表示等等。
 
 这道题的思路，如果我们不考虑用一个字节去存储的话，我们通过观察
 坐标，发现“坐标和 3 取余的结果相同的就是同一列”，因此我们可以根据

problems/1011.capacity-to-ship-packages-within-d-days.md

@@ -66,17 +66,16 @@ https://leetcode-cn.com/problems/capacity-to-ship-packages-within-d-days
 ```python
 def canShip(opacity):
     # 指定船的容量是否可以在D天运完
-lo = 0
-hi = total
-while lo < hi:
-    mid = (lo + hi) // 2
-    if canShip(mid):
-        hi = mid
-    else:
-        lo = mid + 1
-
-return lo
-
+    lo = 0
+    hi = total
+    while lo < hi:
+        mid = (lo + hi) // 2
+        if canShip(mid):
+            hi = mid
+        else:
+            lo = mid + 1
+
+    return lo
 ```
 
 ## 关键点解析
@@ -85,6 +84,10 @@ return lo
 
 ## 代码
 
+* 语言支持：`JS`，`Python`
+
+`python`:
+
 ```python
 class Solution:
     def shipWithinDays(self, weights: List[int], D: int) -> int:
@@ -115,6 +118,50 @@ class Solution:
         return lo
 ```
 
+`js`:
+
+```js
+/**
+ * @param {number[]} weights
+ * @param {number} D
+ * @return {number}
+ */
+var shipWithinDays = function(weights, D) {
+  let high = weights.reduce((acc, cur) => acc + cur)
+  let low = 0
+
+  while(low < high) {
+    let mid = Math.floor((high + low) / 2)
+    if (canShip(mid)) {
+      high = mid
+    } else {
+      low = mid + 1
+    }
+  }
+
+  return low
+
+  function canShip(opacity) {
+    let remain = opacity
+    let count = 1
+    for (let weight of weights) {
+      if (weight > opacity) {
+        return false
+      }
+      remain -= weight
+      if (remain < 0) {
+        count++
+        remain = opacity - weight
+      }
+      if (count > D) {
+        return false
+      }
+    }
+    return count <= D
+  }
+};
+```
+
 ## 扩展
 
 ## 参考

problems/887.super-egg-drop.md

@@ -108,88 +108,8 @@ Note:
 
 ## 代码
 
-```js
 
-/*
- * @lc app=leetcode id=887 lang=javascript
- *
- * [887] Super Egg Drop
- *
- * https://leetcode.com/problems/super-egg-drop/description/
- *
- * algorithms
- * Hard (24.64%)
- * Total Accepted:    6.2K
- * Total Submissions: 24.9K
- * Testcase Example:  '1\n2'
- *
- * You are given K eggs, and you have access to a building with N floors from 1
- * to N.
- *
- * Each egg is identical in function, and if an egg breaks, you cannot drop it
- * again.
- *
- * You know that there exists a floor F with 0 <= F <= N such that any egg
- * dropped at a floor higher than F will break, and any egg dropped at or below
- * floor F will not break.
- *
- * Each move, you may take an egg (if you have an unbroken one) and drop it
- * from any floor X (with 1 <= X <= N).
- *
- * Your goal is to know with certainty what the value of F is.
- *
- * What is the minimum number of moves that you need to know with certainty
- * what F is, regardless of the initial value of F?
- *
- *
- *
- *
- *
- *
- *
- * Example 1:
- *
- *
- * Input: K = 1, N = 2
- * Output: 2
- * Explanation:
- * Drop the egg from floor 1.  If it breaks, we know with certainty that F = 0.
- * Otherwise, drop the egg from floor 2.  If it breaks, we know with certainty
- * that F = 1.
- * If it didn't break, then we know with certainty F = 2.
- * Hence, we needed 2 moves in the worst case to know what F is with
- * certainty.
- *
- *
- *
- * Example 2:
- *
- *
- * Input: K = 2, N = 6
- * Output: 3
- *
- *
- *
- * Example 3:
- *
- *
- * Input: K = 3, N = 14
- * Output: 4
- *
- *
- *
- *
- * Note:
- *
- *
- * 1 <= K <= 100
- * 1 <= N <= 10000
- *
- *
- *
- *
- *
- */
+```js
 /**
  * @param {number} K
  * @param {number} N
@@ -205,7 +125,6 @@ var superEggDrop = function(K, N) {
       for (let k = 1; k <= K; ++k)
           dp[m][k] = dp[m - 1][k - 1] + 1 + dp[m - 1][k];
   }
-  console.log(dp);
   return m;
 };
 ```

problems/98.validate-binary-search-tree.md

@@ -41,7 +41,7 @@ Explanation: The root node's value is 5 but its right child's value is 4.
 我们只需要中序遍历，然后两两判断是否有逆序的元素对即可，如果有，则不是BST，否则即为一个BST。
 
 ### 定义法
-根据定义，一个结点若是在根的左子树上，那它应该小于根结点的值而大于左子树最大值；若是在根的右子树上，那它应该大于根结点的值而小于右子树最小值。也就是说，每一个结点必须落在某个取值范围：
+根据定义，一个结点若是在根的左子树上，那它应该小于根结点的值而大于左子树最小值；若是在根的右子树上，那它应该大于根结点的值而小于右子树最大值。也就是说，每一个结点必须落在某个取值范围：
 1. 根结点的取值范围为（考虑某个结点为最大或最小整数的情况）：(long_min, long_max)
 2. 左子树的取值范围为：(current_min, root.value)
 3. 右子树的取值范围为：(root.value, current_max)
@@ -151,7 +151,7 @@ public:
 };
 ```
 
-Java Implementation
+Java Code:
 
 ```java
 /**
@@ -185,7 +185,7 @@ class Solution {
 
 ### 定义法
 
-* 语言支持：C++，Python3, Java
+* 语言支持：C++，Python3, Java, JS
 
 C++ Code：
 
@@ -311,6 +311,34 @@ class Solution {
 }
 ```
 
+JavaScript Code:
+
+```javascript
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+var isValidBST = function (root) {
+    if (!root) return true;
+    return valid(root);
+};
+
+function valid(root, min = -Infinity, max = Infinity) {
+    if (!root) return true;
+    const val = root.val;
+    if (val <= min) return false;
+    if (val >= max) return false;
+    return valid(root.left, min, val) && valid(root.right, val, max)
+}
+```
+
 ## 相关题目
 
 [230.kth-smallest-element-in-a-bst](./230.kth-smallest-element-in-a-bst.md)