feat: add solutions to lc problem: No.1631

No.1631.Path With Minimum Effort

Author: yanglbme

solution/1300-1399/1368.Minimum Cost to Make at Least One Valid Path in a Grid/README.md

@@ -79,7 +79,11 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-双端队列 BFS。
+双端队列 BFS。本题实际上也是最短路问题，只不过求解的是改变方向的最小次数。
+
+在一个边权只有 0、1 的无向图中搜索最短路径可以使用双端队列进行 BFS。其原理是当前可以扩展到的点的权重为 0 时，将其加入队首；权重为 1 时，将其加入队尾。
+
+> 如果某条边权值为 0，那么新拓展出的节点权值就和当前队首节点权值相同，显然可以作为下一次拓展的起点。
 
 <!-- tabs:start -->
 

solution/1300-1399/1368.Minimum Cost to Make at Least One Valid Path in a Grid/README_EN.md

@@ -72,6 +72,8 @@ The total cost = 3.
 
 ## Solutions
 
+BFS using deque.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1600-1699/1631.Path With Minimum Effort/README.md

@@ -58,7 +58,11 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-并查集。
+**方法一：并查集**
+
+对于本题，每个格子当做图的一个节点，把相邻两个格子的高度差绝对值当做边的权重，因此本题是求解从最左上角的节点到最右下角的节点的连通性问题。
+
+先把图中所有边去掉，然后按照边的权重从小到大，逐个把边添加上。如果在某一次添加一条边时，最左上角和最右下角的节点连通了，那么该边的权重就是题目的最小体力消耗值。
 
 并查集模板：
 
@@ -119,34 +123,35 @@ p[find(a)] = find(b)
 d[find(a)] = distance
 ```
 
-对于本题，每个格子当做图的一个节点，把相邻两个格子的高度差绝对值当做边的权重，因此本题是求解从最左上角的节点到最右下角的节点的连通性问题。
+**方法二：二分查找 + BFS**
 
-先把图中所有边去掉，然后按照边的权重从小到大，逐个把边添加上。如果在某一次添加一条边时，最左上角和最右下角的节点连通了，那么该边的权重就是题目的最小体力消耗值。
+二分枚举体力消耗值，用 BFS 找到满足条件的最小消耗值即可。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+并查集：
+
 ```python
 class Solution:
     def minimumEffortPath(self, heights: List[List[int]]) -> int:
-        m, n = len(heights), len(heights[0])
-        p = list(range(m * n))
-
         def find(x):
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
 
+        m, n = len(heights), len(heights[0])
+        p = list(range(m * n))
         e = []
         for i in range(m):
             for j in range(n):
                 if i < m - 1:
-                    e.append([abs(heights[i][j] - heights[i + 1][j]), i * n + j, (i + 1) * n + j])
+                    e.append((abs(heights[i][j] - heights[i + 1][j]), i * n + j, (i + 1) * n + j))
                 if j < n - 1:
-                    e.append([abs(heights[i][j] - heights[i][j + 1]), i * n + j, i * n + j + 1])
+                    e.append((abs(heights[i][j] - heights[i][j + 1]), i * n + j, i * n + j + 1))
         e.sort()
         for h, i, j in e:
             p[find(i)] = find(j)
@@ -155,16 +160,44 @@ class Solution:
         return 0
 ```
 
+二分查找 + BFS：
+
+```python
+class Solution:
+    def minimumEffortPath(self, heights: List[List[int]]) -> int:
+        m, n = len(heights), len(heights[0])
+        left, right = 0, 999999
+        while left < right:
+            mid = (left + right) >> 1
+            q = deque([(0, 0)])
+            vis = set([(0, 0)])
+            while q:
+                i, j = q.popleft()
+                for a, b in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
+                    x, y = i + a, j + b
+                    if 0 <= x < m and 0 <= y < n and (x, y) not in vis and abs(heights[i][j] - heights[x][y]) <= mid:
+                        q.append((x, y))
+                        vis.add((x, y))
+            if (m - 1, n - 1) in vis:
+                right = mid
+            else:
+                left = mid + 1
+        return left
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+并查集：
+
 ```java
 class Solution {
     private int[] p;
 
     public int minimumEffortPath(int[][] heights) {
-        int m = heights.length, n = heights[0].length;
+        int m = heights.length;
+        int n = heights[0].length;
         p = new int[m * n];
         for (int i = 0; i < p.length; ++i) {
             p[i] = i;
@@ -200,8 +233,48 @@ class Solution {
 }
 ```
 
+二分查找 + BFS：
+
+```java
+class Solution {
+    public int minimumEffortPath(int[][] heights) {
+        int m = heights.length;
+        int n = heights[0].length;
+        int left = 0;
+        int right = 999999;
+        int[] dirs = {-1, 0, 1, 0, -1};
+        while (left < right) {
+            int mid = (left + right) >> 1;
+            boolean[][] vis = new boolean[m][n];
+            vis[0][0] = true;
+            Deque<int[]> q = new ArrayDeque<>();
+            q.offer(new int[]{0, 0});
+            while (!q.isEmpty()) {
+                int[] p = q.poll();
+                int i = p[0], j = p[1];
+                for (int k = 0; k < 4; ++k) {
+                    int x = i + dirs[k], y = j + dirs[k + 1];
+                    if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && Math.abs(heights[i][j] - heights[x][y]) <= mid) {
+                        q.offer(new int[]{x, y});
+                        vis[x][y] = true;
+                    }
+                }
+            }
+            if (vis[m - 1][n - 1]) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}
+```
+
 ### **C++**
 
+并查集：
+
 ```cpp
 class Solution {
 public:
@@ -221,7 +294,7 @@ public:
             }
         }
         sort(edges.begin(), edges.end());
-        for (auto e : edges)
+        for (auto& e : edges)
         {
             int i = e[1], j = e[2];
             p[find(i)] = find(j);
@@ -237,26 +310,71 @@ public:
 };
 ```
 
+二分查找 + BFS：
+
+```cpp
+class Solution {
+public:
+    int minimumEffortPath(vector<vector<int>>& heights) {
+        int m = heights.size(), n = heights[0].size();
+        int left = 0, right = 999999;
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        while (left < right)
+        {
+            int mid = (left + right) >> 1;
+            vector<vector<bool>> vis(m, vector<bool>(n));
+            vis[0][0] = true;
+            queue<pair<int, int>> q;
+            q.push({0, 0});
+            while (!q.empty())
+            {
+                auto [i, j] = q.front();
+                q.pop();
+                for (int k = 0; k < 4; ++k)
+                {
+                    int x = i + dirs[k], y = j + dirs[k + 1];
+                    if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && abs(heights[i][j] - heights[x][y]) <= mid)
+                    {
+                        q.push({x, y});
+                        vis[x][y] = true;
+                    }
+                }
+            }
+            if (vis[m - 1][n - 1]) right = mid;
+            else left = mid + 1;
+        }
+        return left;
+    }
+};
+```
+
 ### **Go**
 
-```go
-var p []int
+并查集：
 
+```go
 func minimumEffortPath(heights [][]int) int {
 	m, n := len(heights), len(heights[0])
-	p = make([]int, m*n)
-	for i := 0; i < len(p); i++ {
+	p := make([]int, m*n)
+	for i := range p {
 		p[i] = i
 	}
-	var edges [][]int
-	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
+	var find func(x int) int
+	find = func(x int) int {
+		if p[x] != x {
+			p[x] = find(p[x])
+		}
+		return p[x]
+	}
+	edges := [][]int{}
+	for i, row := range heights {
+		for j, h := range row {
 			if i < m-1 {
-				s := []int{abs(heights[i][j] - heights[i+1][j]), i*n + j, (i+1)*n + j}
+				s := []int{abs(h - heights[i+1][j]), i*n + j, (i+1)*n + j}
 				edges = append(edges, s)
 			}
 			if j < n-1 {
-				s := []int{abs(heights[i][j] - heights[i][j+1]), i*n + j, i*n + j + 1}
+				s := []int{abs(h - row[j+1]), i*n + j, i*n + j + 1}
 				edges = append(edges, s)
 			}
 		}
@@ -274,11 +392,48 @@ func minimumEffortPath(heights [][]int) int {
 	return 0
 }
 
-func find(x int) int {
-	if p[x] != x {
-		p[x] = find(p[x])
+func abs(x int) int {
+	if x > 0 {
+		return x
+	}
+	return -x
+}
+```
+
+二分查找 + BFS：
+
+```go
+func minimumEffortPath(heights [][]int) int {
+	m, n := len(heights), len(heights[0])
+	left, right := 0, 999999
+	dirs := []int{-1, 0, 1, 0, -1}
+	for left < right {
+		mid := (left + right) >> 1
+		vis := make([][]bool, m)
+		for i := range vis {
+			vis[i] = make([]bool, n)
+		}
+		vis[0][0] = true
+		q := [][]int{{0, 0}}
+		for len(q) > 0 {
+			p := q[0]
+			q = q[1:]
+			i, j := p[0], p[1]
+			for k := 0; k < 4; k++ {
+				x, y := i+dirs[k], j+dirs[k+1]
+				if x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && abs(heights[i][j]-heights[x][y]) <= mid {
+					q = append(q, []int{x, y})
+					vis[x][y] = true
+				}
+			}
+		}
+		if vis[m-1][n-1] {
+			right = mid
+		} else {
+			left = mid + 1
+		}
 	}
-	return p[x]
+	return left
 }
 
 func abs(x int) int {