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

Author: lucifer

README.en.md

@@ -235,7 +235,7 @@ The data structures mainly include:
 - [0023.merge-k-sorted-lists](./problems/23.merge-k-sorted-lists.md)
 - [0025.reverse-nodes-in-k-group](./problems/25.reverse-nodes-in-k-groups-en.md) 🆕✅
 - [0032.longest-valid-parentheses](./problems/32.longest-valid-parentheses.md) 🆕
-- [0042.trapping-rain-water](./problems/42.trapping-rain-water.md)
+- [0042.trapping-rain-water](./problems/42.trapping-rain-water.en.md)🆕✅
 - [0052.N-Queens-II](./problems/52.N-Queens-II.md) 🆕
 - [0124.binary-tree-maximum-path-sum](./problems/124.binary-tree-maximum-path-sum.md)
 - [0128.longest-consecutive-sequence](./problems/128.longest-consecutive-sequence.md)

problems/124.binary-tree-maximum-path-sum.md

@@ -78,7 +78,7 @@ Output: 42
 
 ## 代码
 
-代码支持：JavaScript，Java
+代码支持：JavaScript，Java，Python
 
 - JavaScript
 
@@ -154,5 +154,26 @@ class Solution {
 }
 ```
 
+- Python
+
+```py
+
+class Solution:
+    ans = float('-inf')
+    def maxPathSum(self, root: TreeNode) -> int:
+        def helper(node):
+            if not node: return 0
+            l = helper(node.left)
+            r = helper(node.right)
+            self.ans = max(self.ans, max(l,0) + max(r, 0) + node.val)
+            return max(l, r, 0) + node.val
+        helper(root)
+        return self.ans
+ ```
+
 ## 相关题目
 - [113.path-sum-ii](./113.path-sum-ii.md)
+
+## 扩展
+
+实际上这道题，当遍历到某一个节点的时候，我们需要子节点的信息，然后同时结合自身的 val 来决定要不要选取左右子树。 因此这个过程本质上就是`后序遍历`。

problems/42.trapping-rain-water.en.md

@@ -0,0 +1,130 @@
+## Trapping Rain Water
+https://leetcode.com/problems/trapping-rain-water/description/
+
+## Problem Description
+> Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.
+
+![42.trapping-rain-water-1](../assets/problems/42.trapping-rain-water-1.png)
+
+> The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!
+
+```
+Input: [0,1,0,2,1,0,1,3,2,1,2,1]
+Output: 6
+```
+
+## Solution
+
+The difficulty of this problem is `hard`.
+We'd like to compute how much water a given elevation map can trap.
+
+A brute force solution would be adding up the maximum level of water that each element of the map can trap.
+
+Pseudo Code:
+```js
+for(let i = 0; i < height.length; i++) {
+    area += h[i] - height[i]; // the maximum level of water that the element i can trap
+}
+```
+
+Now the problem becomes how to calculating h[i], which is in fact the minimum of maximum height of bars on both sides minus height[i]:
+`h[i] = Math.min(leftMax, rightMax)` where `leftMax = Math.max(leftMax[i-1], height[i])` and `rightMax = Math.max(rightMax[i+1], height[i])`.
+
+For the given example, h would be [0, 1, 1, 2, 2, 2 ,2, 3, 2, 2, 2, 1].
+
+The key is to calculate `leftMax` and `rightMax`.
+
+## Key Points
+
+- Figure out the modeling of `h[i] = Math.min(leftMax, rightMax)`
+
+## Code (JavaScript/Python3/C++)
+
+JavaScript Code:
+
+```js
+
+/*
+ * @lc app=leetcode id=42 lang=javascript
+ *
+ * [42] Trapping Rain Water
+ *
+ */
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var trap = function(height) {
+    let max = 0;
+    let volumn = 0;
+    const leftMax = [];
+    const rightMax = [];
+
+    for(let i = 0; i < height.length; i++) {
+        leftMax[i] = max = Math.max(height[i], max);
+    }
+
+    max = 0;
+
+    for(let i = height.length - 1; i >= 0; i--) {
+        rightMax[i] = max = Math.max(height[i], max);
+    }
+
+    for(let i = 0; i < height.length; i++) {
+        volumn = volumn +  Math.min(leftMax[i], rightMax[i]) - height[i]
+    }
+
+    return volumn;
+};
+
+```
+
+Python Code:
+
+```python
+class Solution:
+    def trap(self, heights: List[int]) -> int:
+        n = len(heights)
+        l, r = [0] * (n + 1), [0] * (n + 1)
+        ans = 0
+        for i in range(1, len(heights) + 1):
+            l[i] = max(l[i - 1], heights[i - 1])
+        for i in range(len(heights) - 1, 0, -1):
+            r[i] = max(r[i + 1], heights[i])
+        for i in range(len(heights)):
+            ans += max(0, min(l[i + 1], r[i]) - heights[i])
+        return ans     
+```
+
+C++ code:
+
+```c++
+class Solution {
+public:
+    int trap(vector<int>& height) {
+        //check for empty input array
+        if(height.empty())
+            return 0;
+        int size = height.size();
+        int leftMax[size], rightMax[size];
+        //initialization
+        leftMax[0] = height[0];
+        rightMax[size - 1] = height[size - 1];
+        //find leftMax for each element i
+        for(int i = 1; i < size; ++i)
+            leftMax[i] = max(leftMax[i-1], height[i]);
+        //find rightMax for each element i
+        for(int i = size - 2; i >= 0; --i)
+            rightMax[i] = max(rightMax[i+1], height[i]);
+        //caculating the result
+        int ans = 0;
+        for(int i = 0; i < size; ++i)
+            ans += min(leftMax[i], rightMax[i]) - height[i];
+        return ans;
+    }
+};
+```
+
+## Similar Problems
+
+- [84.largest-rectangle-in-histogram](https://github.com/azl397985856/leetcode/blob/master/problems/84.largest-rectangle-in-histogram.md)

thinkings/binary-tree-traversal.md

@@ -103,7 +103,7 @@ BFS 的关键点在于如何记录每一层次是否遍历完成， 我们可以
 
 ## 双色标记法
 
-我们直到垃圾回收算法中，有一种算法叫三色标记法。 即：
+我们知道垃圾回收算法中，有一种算法叫三色标记法。 即：
 
 - 用白色表示尚未访问
 - 灰色表示尚未完全访问子节点
@@ -137,7 +137,7 @@ class Solution:
         return res
 ```
 
-如要实现前序、后序遍历，只需要调整左右子节点的入栈顺序即可。
+如要实现前序、后序遍历，只需要调整左右子节点的入栈顺序即可。可以看出使用三色标记法， 其写法类似递归的形式，因此便于记忆和书写，缺点是使用了额外的内存空间。不过这个额外的空间是线性的，影响倒是不大。
 
 ## Morris 遍历
 

thinkings/bloom-filter.md

@@ -1,44 +1,53 @@
 ## 场景
+
 假设你现在要处理这样一个问题，你有一个网站并且拥有`很多`访客，每当有用户访问时，你想知道这个ip是不是第一次访问你的网站。
 
 ### hashtable 可以么
-一个显而易见的答案是将所有的ip用hashtable存起来，每次访问都去hashtable中取，然后判断即可。但是题目说了网站有`很多`访客，
-假如有10亿个用户访问过，每个ip的长度是4 byte，那么你一共需要4 * 1000000000 = 4000000000Bytes = 4G , 如果是判断URL黑名单，
-由于每个URL会更长，那么需要的空间可能会远远大于你的期望。
+
+一个显而易见的答案是将所有的 IP 用 hashtable 存起来，每次访问都去 hashtable 中取，然后判断即可。但是题目说了网站有`很多`访客，
+假如有10亿个用户访问过，假设 IP 是 IPV4， 那么每个 IP 的长度是 4 byte，那么你一共需要4 * 1000000000 = 4000000000Bytes = 4G 。
+
+如果是判断 URL 黑名单，由于每个 URL 会更长（可能远大于上面 IPV4 地址的 4 byte），那么需要的空间可能会远远大于你的期望。
 
 ### bit
-另一个稍微难想到的解法是bit， 我们知道bit有0和1两种状态，那么用来表示存在，不存在再合适不过了。
 
-加入有10亿个ip，我们就可以用10亿个bit来存储，那么你一共需要 1 * 1000000000 = (4000000000 / 8) Bytes = 128M, 变为原来的1/32,
-如果是存储URL这种更长的字符串，效率会更高。 
+另一个稍微难想到的解法是bit， 我们知道bit有 0 和 1 两种状态，那么用来表示**存在**与**不存在**再合适不过了。
+
+假如有 10 亿个 IP，就可以用 10 亿个 bit 来存储，那么你一共需要 1 * 1000000000 = (4000000000 / 8) Bytes = 128M, 变为原来的1/32, 如果是存储URL这种更长的字符串，效率会更高。 问题是，我们怎么把 IPV4 和 bit 的位置关联上呢？
 
-基于这种想法，我们只需要两个操作，set(ip) 和 has(ip)
+比如`192.168.1.1` 应该是用第几位表示，`10.18.1.1` 应该是用第几位表示呢？ 答案是使用哈希函数。
+
+基于这种想法，我们只需要两个操作，set(ip) 和 has(ip)，以及一个内置函数 hash(ip) 用于将 IP 映射到 bit 表。
 
 这样做有两个非常致命的缺点：
 
 1. 当样本分布极度不均匀的时候，会造成很大空间上的浪费
 
-> 我们可以通过散列函数来解决
+> 我们可以通过优化散列函数来解决
 
 2. 当元素不是整型（比如URL）的时候，BitSet就不适用了
 
 > 我们还是可以使用散列函数来解决， 甚至可以多hash几次
 
 ### 布隆过滤器
 
-布隆过滤器其实就是`bit + 多个散列函数`,  如果经过多次散列的值再bit上都为1，那么可能存在(可能有冲突)。 如果
-有一个不为1，那么一定不存在（一个值经过散列函数得到的值一定是唯一的），这也是布隆过滤器的一个重要特点。
+布隆过滤器其实就是`bit + 多个散列函数`。k 次 hash(ip) 会生成多个索引，并将其 k 个索引位置的二进制置为 1。 如果经过 k 个索引位置的值都为 1，那么认为其**可能存在**(因为有冲突的可能)。 如果有一个不为1，那么**一定不存在**（一个值经过散列函数得到的值一定是唯一的），这也是布隆过滤器的一个重要特点。也就是说布隆过滤器回答了：**可能存在** 和 **一定不存在** 的问题。
 
 ![bloom-filter-url](../assets/thinkings/bloom-filter-url.png)
 
+从上图可以看出， 布隆过滤器本质上是由**一个很长的二进制向量**和**多个哈希函数**组成。
+
+由于没有 hashtable 的100% 可靠性，因此这本质上是一种**可靠性换取空间的做法**。除了可靠性，布隆过滤器删除起来也比较麻烦。
+
 ### 布隆过滤器的应用
 
 1. 网络爬虫
+
 判断某个URL是否已经被爬取过
 
 2. K-V数据库 判断某个key是否存在
 
-比如Hbase的每个Region中都包含一个BloomFilter，用于在查询时快速判断某个key在该region中是否存在。
+比如 Hbase 的每个 Region 中都包含一个 BloomFilter，用于在查询时快速判断某个 key 在该 region 中是否存在。
 
 3. 钓鱼网站识别