fix: 若干小修复

Author: lucifer

problems/295.find-median-from-data-stream.md

@@ -22,7 +22,7 @@ double findMedian() - 返回目前所有元素的中位数。
 addNum(1)
 addNum(2)
 findMedian() -> 1.5
-addNum(3) 
+addNum(3)
 findMedian() -> 2
 进阶:
 
@@ -41,7 +41,7 @@ findMedian() -> 2
 - 阿里
 - 百度
 - 字节
-  
+
 ## 思路
 
 这道题目是求动态数据的中位数，在 leetcode 难度为`hard`. 如果这道题是求静态数据的中位数，我们用数组去存储，
@@ -88,6 +88,7 @@ function findMedian(a) {
 再比如对于[1,2,3, 4] 求中位数：
 
 ![295.find-median-from-data-stream-2](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlty1ld04j30mx06ljrm.jpg)
+
 ## 关键点解析
 
 - 用两个堆（一个大顶堆，一个小顶堆）来简化时间复杂度
@@ -96,15 +97,20 @@ function findMedian(a) {
 > JavaScript 不像 Java， C++等语言都有`优先级队列`中这种数据结构， 因此大家可以使用社区的实现
 > 个人认为没有非要纠结于优先级队列怎么实现， 至少这道题不是考这个的
 > 优先级队列的实现个人认为已经超过了这道题想考察的范畴
+
 ## 代码
 
+代码支持：CPP，JS
+
+JS Code：
+
 如果不使用现成的`优先级队列`这种数据结构，代码可能是这样的：
 
 ```js
 /**
  * initialize your data structure here.
  */
-var MedianFinder = function() {
+var MedianFinder = function () {
   this.maxHeap = [];
   this.minHeap = [];
 };
@@ -118,7 +124,8 @@ function minHeapify() {
   // 其实可以降到O(logn)， 具体细节我不想在这里讲解和实现
   for (let i = a.length - 1; i >> 1 > 0; i--) {
     // 自下往上堆化
-    if (a[i] < a[i >> 1]) { // 如果子元素更小，则交换位置
+    if (a[i] < a[i >> 1]) {
+      // 如果子元素更小，则交换位置
       const temp = a[i];
       this.minHeap[i] = a[i >> 1];
       this.minHeap[i >> 1] = temp;
@@ -136,7 +143,8 @@ function maxHeapify() {
   // 其实可以降到O(logn)， 具体细节我不想在这里讲解和实现
   for (let i = a.length - 1; i >> 1 > 0; i--) {
     // 自下往上堆化
-    if (a[i] > a[i >> 1]) { // 如果子元素更大，则交换位置
+    if (a[i] > a[i >> 1]) {
+      // 如果子元素更大，则交换位置
       const temp = a[i];
       this.maxHeap[i] = a[i >> 1];
       this.maxHeap[i >> 1] = temp;
@@ -149,7 +157,7 @@ function maxHeapify() {
  * @param {number} num
  * @return {void}
  */
-MedianFinder.prototype.addNum = function(num) {
+MedianFinder.prototype.addNum = function (num) {
   // 为了大家容易理解，这部分代码写的比较冗余
 
   // 插入
@@ -185,7 +193,7 @@ MedianFinder.prototype.addNum = function(num) {
 /**
  * @return {number}
  */
-MedianFinder.prototype.findMedian = function() {
+MedianFinder.prototype.findMedian = function () {
   if ((this.maxHeap.length + this.minHeap.length) % 2 === 0) {
     return (this.minHeap[0] + this.maxHeap[0]) / 2;
   } else {
@@ -201,30 +209,28 @@ MedianFinder.prototype.findMedian = function() {
  */
 ```
 
-其中`minHeapify` 和  `maxHeapify` 的过程都有一个hack操作，就是：
+其中`minHeapify` 和 `maxHeapify` 的过程都有一个 hack 操作，就是：
 
 ```js
-
 this.heap.unshift(null);
 // ....
 this.heap.shift(null);
-
 ```
 
-其实就是为了存储的数据从1开始，这样方便计算。 即对于下标为i的元素， `i >> 1` 一定是父节点的下标。
+其实就是为了存储的数据从 1 开始，这样方便计算。 即对于下标为 i 的元素， `i >> 1` 一定是父节点的下标。
 
 ![295.find-median-from-data-stream-3](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlty4xqrrj30n706z3yu.jpg)
 
 > 这是因为我用满二叉树来存储的堆
 
-这个实现比较繁琐，下面介绍一种优雅的方式，假设JS和Java和C++等语言一样有`PriorityQueue`这种数据结构，那么我们实现就比较简单了。
+这个实现比较繁琐，下面介绍一种优雅的方式，假设 JS 和 Java 和 C++等语言一样有`PriorityQueue`这种数据结构，那么我们实现就比较简单了。
 
 代码：
 
-> 关于PriorityQueue的实现，感兴趣的可以看下 https://github.com/janogonzalez/priorityqueuejs
+> 关于 PriorityQueue 的实现，感兴趣的可以看下 https://github.com/janogonzalez/priorityqueuejs
 
 ```js
-var MedianFinder = function() {
+var MedianFinder = function () {
   this.maxHeap = new PriorityQueue((a, b) => a - b);
   this.minHeap = new PriorityQueue((a, b) => b - a);
 };
@@ -233,37 +239,38 @@ var MedianFinder = function() {
  * @param {number} num
  * @return {void}
  */
-MedianFinder.prototype.addNum = function(num) {
-    // 我们的目标就是建立两个堆，一个大顶堆，一个小顶堆
-    // 结合中位数的特点
-    // 这两个堆需要满足:
-    // 1. 大顶堆元素都比小顶堆小（由于堆的特点其实只要比较堆顶即可）
-    // 2. 大顶堆元素不小于小顶堆，且最多比小顶堆多一个元素
-
-    // 满足上面两个条件的话，如果想要找到中位数，就比较简单了
-    // 如果两个堆数量相等（本质是总数为偶数）, 就两个堆顶元素的平均数
-    // 如果两个堆数量不相等（本质是总数为奇数）， 就取大顶堆的堆顶元素
-
-    // 问题如果保证满足上述两个特点
-
-    // 1. 保证第一点
-    this.maxHeap.enq(num);
-    // 由于小顶堆的所有数都来自大顶堆的堆顶元素（最大值）
-    // 因此可以保证第一点
-    this.minHeap.enq(this.maxHeap.deq());
-
-    // 2. 保证第二点
-    if (this.maxHeap.size() < this.minHeap.size()){
-        this.maxHeap.enq(this.minHeap.deq());
-    }
+MedianFinder.prototype.addNum = function (num) {
+  // 我们的目标就是建立两个堆，一个大顶堆，一个小顶堆
+  // 结合中位数的特点
+  // 这两个堆需要满足:
+  // 1. 大顶堆元素都比小顶堆小（由于堆的特点其实只要比较堆顶即可）
+  // 2. 大顶堆元素不小于小顶堆，且最多比小顶堆多一个元素
+
+  // 满足上面两个条件的话，如果想要找到中位数，就比较简单了
+  // 如果两个堆数量相等（本质是总数为偶数）, 就两个堆顶元素的平均数
+  // 如果两个堆数量不相等（本质是总数为奇数）， 就取大顶堆的堆顶元素
+
+  // 问题如果保证满足上述两个特点
+
+  // 1. 保证第一点
+  this.maxHeap.enq(num);
+  // 由于小顶堆的所有数都来自大顶堆的堆顶元素（最大值）
+  // 因此可以保证第一点
+  this.minHeap.enq(this.maxHeap.deq());
+
+  // 2. 保证第二点
+  if (this.maxHeap.size() < this.minHeap.size()) {
+    this.maxHeap.enq(this.minHeap.deq());
+  }
 };
 
 /**
  * @return {number}
  */
-MedianFinder.prototype.findMedian = function() {
-    if (this.maxHeap.size() == this.minHeap.size()) return (this.maxHeap.peek() + this.minHeap.peek()) /  2.0;
-    else return this.maxHeap.peek();
+MedianFinder.prototype.findMedian = function () {
+  if (this.maxHeap.size() == this.minHeap.size())
+    return (this.maxHeap.peek() + this.minHeap.peek()) / 2.0;
+  else return this.maxHeap.peek();
 };
 
 /**
@@ -272,5 +279,60 @@ MedianFinder.prototype.findMedian = function() {
  * obj.addNum(num)
  * var param_2 = obj.findMedian()
  */
+```
 
+CPP Code：
+
+```cpp
+class MedianFinder {
+public:
+    /** initialize your data structure here. */
+    MedianFinder() {
+
+    }
+
+    void addNum(int num) {
+        if (big_queue.empty()) {
+            big_queue.push(num);
+            return;
+        }
+        if (big_queue.size() == small_queue.size()) {
+            if (num <= big_queue.top()) {
+                big_queue.push(num);
+            } else {
+                small_queue.push(num);
+            }
+        } else if (big_queue.size() > small_queue.size()) {
+            if (big_queue.top() > num) {
+                small_queue.push(big_queue.top());
+                big_queue.pop();
+                big_queue.push(num);
+            } else {
+                small_queue.push(num);
+            }
+        } else if (big_queue.size() < small_queue.size()) {
+            if (small_queue.top() > num) {
+                big_queue.push(num);
+            } else {
+                big_queue.push(small_queue.top());
+                small_queue.pop();
+                small_queue.push(num);
+            }
+        }
+    }
+
+    double findMedian() {
+        if (big_queue.size() == small_queue.size()) {
+            return (big_queue.top() + small_queue.top()) * 0.5;
+        }
+        if (big_queue.size() < small_queue.size()) {
+            return small_queue.top();
+        }
+        return big_queue.top();
+    }
+
+private:
+    std::priority_queue<int, std::vector<int>, std::greater<int>> small_queue;  // 最小堆
+    std::priority_queue<int> big_queue; // 最大堆
+};
 ```

problems/472.concatenated-words.md

@@ -66,6 +66,10 @@ https://leetcode-cn.com/problems/concatenated-words/
 
 由于我们并不知道 cat 这里断开，结果更大？还是 cats 这里断开结果更大？因此我们的做法是将其全部递归求出，然后取出最大值即可。如果我们直接这样递归的话，可能会超时，卡在最后一个测试用例上。一个简单的方式是记忆化递归，从而避免重复计算，经测试这种方法能够通过。
 
+## 关键点分析
+
+- 前缀树
+
 ## 代码
 
 代码支持：Python3
@@ -118,10 +122,6 @@ class Solution:
         return res
 ```
 
-## 关键点分析
-
-- 前缀树
-
 ## 相关题目
 
 - [0208.implement-trie-prefix-tree](https://github.com/azl397985856/leetcode/blob/b8e8fa5f0554926efa9039495b25ed7fc158372a/problems/208.implement-trie-prefix-tree.md)

thinkings/union-find.en.md

@@ -1,6 +1,6 @@
 # Union Find Data Structure
 
-Leetcode has many problems concerning the union-find data structure. To be specific, the official number is 30(until 2020-02-20). And some problems, though not labeled with `Union Find`, can be solved more easily by applying this data structure. A problem-solving pattern can be found among this kind of problem. Once you have grasped the pattern, you can solve these problems with higher speed and fewer mistakes, which is the benefit of using patterns. 
+Leetcode has many problems concerning the union-find data structure. To be specific, the official number is 30(until 2020-02-20). And some problems, though not labeled with `Union Find`, can be solved more easily by applying this data structure. A problem-solving pattern can be found among this kind of problem. Once you have grasped the pattern, you can solve these problems with higher speed and fewer mistakes, which is the benefit of using patterns.
 
 Related problems:
 
@@ -100,9 +100,9 @@ class UF:
 
     def find(self, x):
         while x != self.parent[x]:
-            x = self.parent[x]
             # path compression
             self.parent[x] = self.parent[self.parent[x]];
+            x = self.parent[x]
         return x
     def union(self, p, q):
         if self.connected(p, q): return
@@ -117,30 +117,3 @@ class UF:
     def connected(self, p, q):
         return self.find(p) == self.find(q)
 ```
-
-The code above implements path compression with recursion, which, though is easier to write, contains the risk of stack overflow. The following is how we can do it with iteration.
-
-```python
-class UF:
-    parent = {}
-    def __init__(self, equations):
-        # Initiation
-
-    def find(self, x):
-        # root
-        r = x
-        while r != parent[r]:
-            r = parent[r]
-        k = x
-        while k != r:
-            # Store the parent node of parent[k] temporarily.
-            j = parent[k]
-            parent[k] = r
-            k = j
-        return r
-    def union(self, p, q):
-        if self.connected(p, q): return
-        self.parent[self.find(p)] = self.find(q)
-    def connected(self, p, q):
-        return self.find(p) == self.find(q)
-```

thinkings/union-find.md

@@ -8,8 +8,9 @@
 - [721. 账户合并](https://leetcode-cn.com/problems/accounts-merge/solution/mo-ban-ti-bing-cha-ji-python3-by-fe-lucifer-3/)
 - [990. 等式方程的可满足性](https://github.com/azl397985856/leetcode/issues/304)
 - [1202. 交换字符串中的元素](https://leetcode-cn.com/problems/smallest-string-with-swaps/)
+- [1697. 检查边长度限制的路径是否存在](https://leetcode-cn.com/problems/checking-existence-of-edge-length-limited-paths/)
 
-看完这里的内容，建议拿上面的题目练下手，检测一下学习成果。
+上面的题目前面四道都是无权图的连通性问题，第五道题是带权图的连通性问题。两种类型大家都要会，上面的题目关键字都是**连通性**，代码都是套模板。看完这里的内容，建议拿上面的题目练下手，检测一下学习成果。
 
 ## 概述
 
@@ -101,9 +102,9 @@ class UF:
 
     def find(self, x):
         while x != self.parent[x]:
-            x = self.parent[x]
             # 路径压缩
             self.parent[x] = self.parent[self.parent[x]];
+            x = self.parent[x]
         return x
     def union(self, p, q):
         if self.connected(p, q): return
@@ -121,35 +122,8 @@ class UF:
         return self.find(p) == self.find(q)
 ```
 
-上面是递归的方式进行路径压缩，写起来比较简单。但是有栈溢出的风险。 接下来我们看下迭代的写法：
-
-```python
-class UF:
-    parent = {}
-    def __init__(self, equations):
-        # 做一些初始化操作
-
-    def find(self, x):
-        # 根节点
-        r = x
-        while r != parent[r]:
-            r = parent[r]
-        k = x
-        while k != r:
-            # 暂存parent[k]的父节点
-            j = parent[k]
-            parent[k] = r
-            k = j
-        return r
-    def union(self, p, q):
-        if self.connected(p, q): return
-        self.parent[self.find(p)] = self.find(q)
-    def connected(self, p, q):
-        return self.find(p) == self.find(q)
-```
-
 ## 总结
 
 如果题目有连通，等价的关系，那么你就可以考虑并查集，使用并查集的时候要注意路径压缩。
 
-本文提供的题目模板是西法我用的比较多的，用了它不仅出错概率大大降低，而且速度也快了很多，整个人都更自信了呢 ^_^
+本文提供的题目模板是西法我用的比较多的，用了它不仅出错概率大大降低，而且速度也快了很多，整个人都更自信了呢 ^\_^