improved reading

Author: dashidhy

basic_algorithm/dp.md

@@ -134,10 +134,16 @@ Function(x) {
 > 给定一个包含非负整数的  *m* x *n*  网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
 
 思路：动态规划
-1、state: f[x][y]从起点走到 x,y 的最短路径
-2、function: f[x][y] = min(f[x-1][y], f[x][y-1]) + A[x][y]
-3、intialize: f[0][0] = A[0][0]、f[i][0] = sum(0,0 -> i,0)、 f[0][i] = sum(0,0 -> 0,i)
-4、answer: f[n-1][m-1]
+
+1. state: f(x, y) 从起点走到 (x, y) 的最短路径 
+
+2. function: f(x, y) = min(f(x - 1, y), f(x, y - 1]) + A(x, y)
+
+3. intialize: f(0, 0) = A(0, 0)、f(i, 0) = sum(0,0 -> i,0)、 f(0, i) = sum(0,0 -> 0,i)
+
+4. answer: f(n - 1, m - 1)
+
+5. 2D DP -> 1D DP
 
 ```Python
 class Solution:

basic_algorithm/graph/bfs_dfs.md

@@ -82,7 +82,7 @@ def BFS(x):
 
 > 给定一个二维矩阵，矩阵中元素 -1 表示墙或是障碍物，0 表示一扇门，INF (2147483647) 表示一个空的房间。你要给每个空房间位上填上该房间到最近门的距离，如果无法到达门，则填 INF 即可。
 
-**图森面试真题**。典型的多源最短路径问题，将所有源作为 BFS 的第一层即可
+典型的多源最短路径问题，将所有源作为 BFS 的第一层即可
 
 ```Python
 inf = 2147483647
@@ -137,7 +137,7 @@ class Solution:
 > 在给定的 01 矩阵 A 中，存在两座岛 (岛是由四面相连的 1 形成的一个连通分量)。现在，我们可以将 0 变为 1，以使两座岛连接起来，变成一座岛。返回必须翻转的 0 的最小数目。
 >
 
-**图森面试真题**。思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径
+思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径
 
 ```Python
 class Solution:

basic_algorithm/graph/mst.md

@@ -4,7 +4,7 @@
 
 > 地图上有 m 条无向边，每条边 (x, y, w) 表示位置 m 到位置 y 的权值为 w。从位置 0 到 位置 n 可能有多条路径。我们定义一条路径的危险值为这条路径中所有的边的最大权值。请问从位置 0 到 位置 n 所有路径中最小的危险值为多少？
 
-**图森面试真题**。最小危险值为最小生成树中 0 到 n 路径上的最大边权。
+最小危险值为最小生成树中 0 到 n 路径上的最大边权。
 
 ```Python
 # Kruskal's algorithm

basic_algorithm/graph/shortest_path.md

@@ -8,7 +8,7 @@
 
 > 给定一个二维矩阵，矩阵中元素 -1 表示墙或是障碍物，0 表示一扇门，INF (2147483647) 表示一个空的房间。你要给每个空房间位上填上该房间到最近门的距离，如果无法到达门，则填 INF 即可。
 
-**图森面试真题**。典型的多源最短路径问题，将所有源作为 BFS 的第一层即可
+典型的多源最短路径问题，将所有源作为 BFS 的第一层即可
 
 ```Python
 inf = 2147483647
@@ -62,7 +62,7 @@ class Solution:
 
 > 在给定的 01 矩阵 A 中，存在两座岛 (岛是由四面相连的 1 形成的一个连通分量)。现在，我们可以将 0 变为 1，以使两座岛连接起来，变成一座岛。返回必须翻转的 0 的最小数目。
 
-**图森面试真题**。思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径
+思路：DFS 遍历连通分量找边界，从边界开始 BFS找最短路径
 
 ```Python
 class Solution:

basic_algorithm/graph/topological_sorting.md

@@ -6,13 +6,10 @@
 
 > 给定课程的先修关系，求一个可行的修课顺序
 
-**图森面试真题**。非常经典的拓扑排序应用题目。下面给出 3 种实现方法，可以当做模板使用。
-
-
-
-方法 1：DFS 的递归实现
+非常经典的拓扑排序应用题目。下面给出 3 种实现方法，可以当做模板使用。
 
 ```Python
+# 方法 1：DFS 的递归实现
 NOT_VISITED = 0
 DISCOVERING = 1
 VISITED = 2
@@ -45,9 +42,8 @@ class Solution:
         return tsort_rev[::-1]
 ```
 
-方法 2：DFS 的迭代实现
-
 ```Python
+# 方法 2：DFS 的迭代实现
 NOT_VISITED = 0
 DISCOVERING = 1
 VISITED = 2
@@ -85,9 +81,8 @@ class Solution:
         return tsort_rev[::-1]
 ```
 
-方法 3：[Kahn's algorithm](https://en.wikipedia.org/wiki/Topological_sorting#Kahn's_algorithm)
-
 ```Python
+# 方法 3：Kahn's algorithm: https://en.wikipedia.org/wiki/Topological_sorting#Kahn's_algorithm
 class Solution:
     def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
 

data_structure/heap.md

@@ -91,7 +91,7 @@ Heap 可以高效地取出或更新当前池中优先级最高的元素，因此
 > 公司有 n 个工程师，给两个数组 speed 和 efficiency，其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。请你返回由最多 k 个工程师组成的团队的最大表现值。表现值的定义为：一个团队中所有工程师速度的和乘以他们效率值中的最小值。
 >
 
-**图森面试真题**。[See my review here.](https://leetcode.com/problems/maximum-performance-of-a-team/discuss/741822/Met-this-problem-in-my-interview!!!-(Python3-greedy-with-heap)) [或者这里(中文)](https://leetcode-cn.com/problems/maximum-performance-of-a-team/solution/greedy-with-min-heap-lai-zi-zhen-shi-mian-shi-de-j/)
+[See my review here.](https://leetcode.com/problems/maximum-performance-of-a-team/discuss/741822/Met-this-problem-in-my-interview!!!-(Python3-greedy-with-heap)) [或者这里(中文)](https://leetcode-cn.com/problems/maximum-performance-of-a-team/solution/greedy-with-min-heap-lai-zi-zhen-shi-mian-shi-de-j/)
 
 ```Python
 class Solution:
@@ -116,7 +116,7 @@ class Solution:
 
 ### [ipo](https://leetcode-cn.com/problems/ipo/)
 
-**图森面试真题**。贪心策略为每次做当前成本范围内利润最大的项目。
+贪心策略为每次做当前成本范围内利润最大的项目。
 
 ```Python
 class Solution:
@@ -143,7 +143,7 @@ class Solution:
 
 ### [meeting-rooms-ii](https://leetcode-cn.com/problems/meeting-rooms-ii/)
 
-**图森面试真题**。此题用 greedy + heap 解并不是很 intuitive，存在复杂度相同但更简单直观的做法。
+此题用 greedy + heap 解并不是很 intuitive，存在复杂度相同但更简单直观的做法。
 
 ```Python
 class Solution:
@@ -207,7 +207,7 @@ class Solution:
 
 > 地图上有 m 条无向边，每条边 (x, y, w) 表示位置 m 到位置 y 的权值为 w。从位置 0 到 位置 n 可能有多条路径。我们定义一条路径的危险值为这条路径中所有的边的最大权值。请问从位置 0 到 位置 n 所有路径中最小的危险值为多少？
 
-**图森面试真题**。最小危险值为最小生成树中 0 到 n 路径上的最大边权。
+最小危险值为最小生成树中 0 到 n 路径上的最大边权。
 
 ```Python
 class Solution:

data_structure/union_find.md

@@ -102,14 +102,14 @@ class Solution:
 
 > 地图上有 m 条无向边，每条边 (x, y, w) 表示位置 m 到位置 y 的权值为 w。从位置 0 到 位置 n 可能有多条路径。我们定义一条路径的危险值为这条路径中所有的边的最大权值。请问从位置 0 到 位置 n 所有路径中最小的危险值为多少？
 
-**图森面试真题**。最小危险值为最小生成树中 0 到 n 路径上的最大边权。
+最小危险值为最小生成树中 0 到 n 路径上的最大边权。
 
 ```Python
 # Kruskal's algorithm
 class Solution:
     def getMinRiskValue(self, N, M, X, Y, W):
 
-        # Kruskal's algorithm with union-find to construct MST
+        # Kruskal's algorithm with union-find
         parent = list(range(N + 1))
 
         def find(x):
@@ -127,28 +127,7 @@ class Solution:
 
         edges = sorted(zip(W, X, Y))
 
-        MST_edges = []        
-        for edge in edges:
-            if union(edge[1], edge[2]):
-                MST_edges.append(edge)
-            if find(0) == find(N):
-                break
-        
-        MST = collections.defaultdict(list)
-        target = find(0)
-        for w, u, v in MST_edges:
-            if find(u) == target and find(v) == target:
-                MST[u].append((v, w))
-                MST[v].append((u, w))
-                
-        # dfs to search route from 0 to n
-        dfs = [(0, None, float('-inf'))]
-        while dfs:
-            v, p, max_w = dfs.pop()
-            for n, w in MST[v]:
-                cur_max_w = max(max_w, w)
-                if n == N:
-                    return cur_max_w
-                if n != p:
-                    dfs.append((n, v, cur_max_w))
+        for w, x, y in edges:
+            if union(x, y) and find(0) == find(N): # early return without constructing MST
+                return w
 ```