feat: add solutions to lc problem: No.1631

No.1631.Path With Minimum Effort

Author: yanglbme

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

@@ -127,6 +127,8 @@ d[find(a)] = distance
 
 二分枚举体力消耗值，用 BFS 找到满足条件的最小消耗值即可。
 
+**方法三：堆优化版 Dijkstra 算法**
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -185,6 +187,27 @@ class Solution:
         return left
 ```
 
+Dijkstra 算法：
+
+```python
+class Solution:
+    def minimumEffortPath(self, heights: List[List[int]]) -> int:
+        INF = 0x3f3f3f3f
+        m, n = len(heights), len(heights[0])
+        dist = [[INF] * n for _ in range(m)]
+        dist[0][0] = 0
+        dirs = [-1, 0, 1, 0, -1]
+        q = [(0, 0, 0)]
+        while q:
+            t, i, j = heappop(q)
+            for k in range(4):
+                x, y = i + dirs[k], j + dirs[k + 1]
+                if 0 <= x < m and 0 <= y < n and max(t, abs(heights[x][y] - heights[i][j])) < dist[x][y]:
+                    dist[x][y] = max(t, abs(heights[x][y] - heights[i][j]))
+                    heappush(q, (dist[x][y], x, y))
+        return dist[-1][-1]
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -271,6 +294,40 @@ class Solution {
 }
 ```
 
+Dijkstra 算法：
+
+```java
+class Solution {
+    public int minimumEffortPath(int[][] heights) {
+        int m = heights.length;
+        int n = heights[0].length;
+        int[][] dist = new int[m][n];
+        for (int i = 0; i < m; ++i) {
+            Arrays.fill(dist[i], 0x3f3f3f3f);
+        }
+        dist[0][0] = 0;
+        PriorityQueue<int[]> q = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+        q.offer(new int[]{0, 0, 0});
+        int[] dirs = {-1, 0, 1, 0, -1};
+        while (!q.isEmpty()) {
+            int[] p = q.poll();
+            int t = p[0], i = p[1], j = p[2];
+            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) {
+                    int nd = Math.max(t, Math.abs(heights[x][y] - heights[i][j]));
+                    if (nd < dist[x][y]) {
+                        dist[x][y] = nd;
+                        q.offer(new int[]{nd, x, y});
+                    }
+                }
+            }
+        }
+        return dist[m - 1][n - 1];
+    }
+}
+```
+
 ### **C++**
 
 并查集：
@@ -348,6 +405,40 @@ public:
 };
 ```
 
+Dijkstra 算法：
+
+```cpp
+class Solution {
+public:
+    int minimumEffortPath(vector<vector<int>>& heights) {
+        int m = heights.size(), n = heights[0].size();
+        vector<vector<int>> dist(m, vector<int>(n, 0x3f3f3f3f));
+        dist[0][0] = 0;
+        priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>, greater<tuple<int, int, int>>> q;
+        q.push({0, 0, 0});
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        while (!q.empty())
+        {
+            auto [t, i, j] = q.top();
+            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)
+                {
+                    int nd = max(t, abs(heights[x][y] - heights[i][j]));
+                    if (nd < dist[x][y])
+                    {
+                        dist[x][y] = nd;
+                        q.push({nd, x, y});
+                    }
+                }
+            }
+        }
+        return dist[m - 1][n - 1];
+    }
+};
+```
 ### **Go**
 
 并查集：

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

@@ -128,6 +128,25 @@ class Solution:
         return left
 ```
 
+```python
+class Solution:
+    def minimumEffortPath(self, heights: List[List[int]]) -> int:
+        INF = 0x3f3f3f3f
+        m, n = len(heights), len(heights[0])
+        dist = [[INF] * n for _ in range(m)]
+        dist[0][0] = 0
+        dirs = [-1, 0, 1, 0, -1]
+        q = [(0, 0, 0)]
+        while q:
+            t, i, j = heappop(q)
+            for k in range(4):
+                x, y = i + dirs[k], j + dirs[k + 1]
+                if 0 <= x < m and 0 <= y < n and max(t, abs(heights[x][y] - heights[i][j])) < dist[x][y]:
+                    dist[x][y] = max(t, abs(heights[x][y] - heights[i][j]))
+                    heappush(q, (dist[x][y], x, y))
+        return dist[-1][-1]
+```
+
 ### **Java**
 
 Union find:
@@ -212,6 +231,38 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int minimumEffortPath(int[][] heights) {
+        int m = heights.length;
+        int n = heights[0].length;
+        int[][] dist = new int[m][n];
+        for (int i = 0; i < m; ++i) {
+            Arrays.fill(dist[i], 0x3f3f3f3f);
+        }
+        dist[0][0] = 0;
+        PriorityQueue<int[]> q = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+        q.offer(new int[]{0, 0, 0});
+        int[] dirs = {-1, 0, 1, 0, -1};
+        while (!q.isEmpty()) {
+            int[] p = q.poll();
+            int t = p[0], i = p[1], j = p[2];
+            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) {
+                    int nd = Math.max(t, Math.abs(heights[x][y] - heights[i][j]));
+                    if (nd < dist[x][y]) {
+                        dist[x][y] = nd;
+                        q.offer(new int[]{nd, x, y});
+                    }
+                }
+            }
+        }
+        return dist[m - 1][n - 1];
+    }
+}
+```
+
 ### **C++**
 
 Union find:
@@ -289,6 +340,39 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int minimumEffortPath(vector<vector<int>>& heights) {
+        int m = heights.size(), n = heights[0].size();
+        vector<vector<int>> dist(m, vector<int>(n, 0x3f3f3f3f));
+        dist[0][0] = 0;
+        priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>, greater<tuple<int, int, int>>> q;
+        q.push({0, 0, 0});
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        while (!q.empty())
+        {
+            auto [t, i, j] = q.top();
+            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)
+                {
+                    int nd = max(t, abs(heights[x][y] - heights[i][j]));
+                    if (nd < dist[x][y])
+                    {
+                        dist[x][y] = nd;
+                        q.push({nd, x, y});
+                    }
+                }
+            }
+        }
+        return dist[m - 1][n - 1];
+    }
+};
+```
+
 ### **Go**
 
 Union find:

solution/1600-1699/1631.Path With Minimum Effort/Solution.cpp

@@ -1,32 +1,30 @@
-class Solution {
-public:
-    vector<int> p;
-
-    int minimumEffortPath(vector<vector<int>>& heights) {
-        int m = heights.size(), n = heights[0].size();
-        p.resize(m * n);
-        for (int i = 0; i < p.size(); ++i) p[i] = i;
-        vector<vector<int>> edges;
-        for (int i = 0; i < m; ++i)
-        {
-            for (int j = 0; j < n; ++j)
-            {
-                if (i < m - 1) edges.push_back({abs(heights[i][j] - heights[i + 1][j]), i * n + j, (i + 1) * n + j});
-                if (j < n - 1) edges.push_back({abs(heights[i][j] - heights[i][j + 1]), i * n + j, i * n + j + 1});
-            }
-        }
-        sort(edges.begin(), edges.end());
-        for (auto& e : edges)
-        {
-            int i = e[1], j = e[2];
-            p[find(i)] = find(j);
-            if (find(0) == find(m * n - 1)) return e[0];
-        }
-        return 0;
-    }
-
-    int find(int x) {
-        if (p[x] != x) p[x] = find(p[x]);
-        return p[x];
-    }
+class Solution {
+public:
+    int minimumEffortPath(vector<vector<int>>& heights) {
+        int m = heights.size(), n = heights[0].size();
+        vector<vector<int>> dist(m, vector<int>(n, 0x3f3f3f3f));
+        dist[0][0] = 0;
+        priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>, greater<tuple<int, int, int>>> q;
+        q.push({0, 0, 0});
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        while (!q.empty())
+        {
+            auto [t, i, j] = q.top();
+            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)
+                {
+                    int nd = max(t, abs(heights[x][y] - heights[i][j]));
+                    if (nd < dist[x][y])
+                    {
+                        dist[x][y] = nd;
+                        q.push({nd, x, y});
+                    }
+                }
+            }
+        }
+        return dist[m - 1][n - 1];
+    }
 };

solution/1600-1699/1631.Path With Minimum Effort/Solution.java

@@ -1,39 +1,29 @@
-class Solution {
-    private int[] p;
-
-    public int minimumEffortPath(int[][] heights) {
-        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;
-        }
-        List<int[]> edges = new ArrayList<>();
-        for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                if (i < m - 1) {
-                    edges.add(new int[]{Math.abs(heights[i][j] - heights[i + 1][j]), i * n + j, (i + 1) * n + j});
-                }
-                if (j < n - 1) {
-                    edges.add(new int[]{Math.abs(heights[i][j] - heights[i][j + 1]), i * n + j, i * n + j + 1});
-                }
-            }
-        }
-        Collections.sort(edges, Comparator.comparingInt(a -> a[0]));
-        for (int[] e : edges) {
-            int i = e[1], j = e[2];
-            p[find(i)] = find(j);
-            if (find(0) == find(m * n - 1)) {
-                return e[0];
-            }
-        }
-        return 0;
-    }
-
-    private int find(int x) {
-        if (p[x] != x) {
-            p[x] = find(p[x]);
-        }
-        return p[x];
-    }
+class Solution {
+    public int minimumEffortPath(int[][] heights) {
+        int m = heights.length;
+        int n = heights[0].length;
+        int[][] dist = new int[m][n];
+        for (int i = 0; i < m; ++i) {
+            Arrays.fill(dist[i], 0x3f3f3f3f);
+        }
+        dist[0][0] = 0;
+        PriorityQueue<int[]> q = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+        q.offer(new int[]{0, 0, 0});
+        int[] dirs = {-1, 0, 1, 0, -1};
+        while (!q.isEmpty()) {
+            int[] p = q.poll();
+            int t = p[0], i = p[1], j = p[2];
+            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) {
+                    int nd = Math.max(t, Math.abs(heights[x][y] - heights[i][j]));
+                    if (nd < dist[x][y]) {
+                        dist[x][y] = nd;
+                        q.offer(new int[]{nd, x, y});
+                    }
+                }
+            }
+        }
+        return dist[m - 1][n - 1];
+    }
 }