Skip to content

Commit 9803359

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1102
No.1102.Path With Maximum Minimum Value
1 parent 359f327 commit 9803359

File tree

6 files changed

+485
-2
lines changed

6 files changed

+485
-2
lines changed

‎solution/1100-1199/1102.Path With Maximum Minimum Value/README.md

Lines changed: 170 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -53,22 +53,191 @@
5353

5454
<!-- 这里可写通用的实现逻辑 -->
5555

56+
并查集。
57+
58+
初始化 ans 为 `min(grid[0][0], grid[m - 1][n - 1])`。并且对 `(0, 0)`, `(m - 1, n - 1)` 进行染色。
59+
60+
将矩阵所有元素及对应的坐标放入数组 scores 中，并根据 score 升序排列。
61+
62+
每次弹出数组最后一个元素（score 最大值），将其染色，并更新 ans 为已经染色的元素的最小值。如果其相邻的元素也被染色，则将他们进行合并。循环直至 `(0, 0)` 与 `(m - 1, n - 1)` 连通。
63+
5664
<!-- tabs:start -->
5765

5866
### **Python3**
5967

6068
<!-- 这里可写当前语言的特殊实现逻辑 -->
6169

6270
```python
63-
71+
class Solution:
72+
def maximumMinimumPath(self, grid: List[List[int]]) -> int:
73+
def find(x):
74+
if p[x] != x:
75+
p[x] = find(p[x])
76+
return p[x]
77+
78+
m, n = len(grid), len(grid[0])
79+
p = list(range(m * n))
80+
ans = min(grid[0][0], grid[-1][-1])
81+
vis = {(0, 0), (m - 1, n - 1)}
82+
scores = [[grid[i][j], i, j] for i in range(m) for j in range(n)]
83+
scores.sort()
84+
while find(0) != find(m * n - 1):
85+
score, i, j = scores.pop()
86+
ans = min(ans, score)
87+
vis.add((i, j))
88+
for a, b in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
89+
x, y = i + a, j + b
90+
if 0 <= x < m and 0 <= y < n and (x, y) in vis:
91+
p[find(x * n + y)] = find(i * n + j)
92+
return ans
6493
```
6594

6695
### **Java**
6796

6897
<!-- 这里可写当前语言的特殊实现逻辑 -->
6998

7099
```java
100+
class Solution {
101+
private int[] p;
102+
103+
public int maximumMinimumPath(int[][] grid) {
104+
int m = grid.length;
105+
int n = grid[0].length;
106+
p = new int[m * n];
107+
for (int i = 0; i < p.length; ++i) {
108+
p[i] = i;
109+
}
110+
int ans = Math.min(grid[0][0], grid[m - 1][n - 1]);
111+
Set<Integer> vis = new HashSet<>(Arrays.asList(0, m * n - 1));
112+
List<int[]> scores = new ArrayList<>();
113+
for (int i = 0; i < m; ++i) {
114+
for (int j = 0; j < n; ++j) {
115+
scores.add(new int[]{grid[i][j], i, j});
116+
}
117+
}
118+
scores.sort(Comparator.comparingInt(a -> a[0]));
119+
int[] dirs = {-1, 0, 1, 0, -1};
120+
while (find(0) != find(m * n - 1)) {
121+
int[] t = scores.remove(scores.size() - 1);
122+
int score = t[0], i = t[1], j = t[2];
123+
ans = Math.min(ans, score);
124+
vis.add(i * n + j);
125+
for (int k = 0; k < 4; ++k) {
126+
int x = i + dirs[k], y = j + dirs[k + 1];
127+
if (x >= 0 && x < m && y >= 0 && y < n && vis.contains(x * n + y)) {
128+
p[find(x * n + y)] = find(i * n + j);
129+
}
130+
}
131+
}
132+
return ans;
133+
}
134+
135+
private int find(int x) {
136+
if (p[x] != x) {
137+
p[x] = find(p[x]);
138+
}
139+
return p[x];
140+
}
141+
}
142+
```
143+
144+
### **C++**
145+
146+
```cpp
147+
class Solution {
148+
public:
149+
vector<int> p;
150+
151+
int maximumMinimumPath(vector<vector<int>>& grid) {
152+
int m = grid.size(), n = grid[0].size();
153+
p.resize(m * n);
154+
for (int i = 0; i < p.size(); ++i) p[i] = i;
155+
int ans = min(grid[0][0], grid[m - 1][n - 1]);
156+
vector<vector<bool>> vis(m, vector<bool>(n));
157+
vis[0][0] = true;
158+
vis[m - 1][n - 1] = true;
159+
vector<tuple<int, int, int>> scores;
160+
for (int i = 0; i < m; ++i)
161+
for (int j = 0; j < n; ++j)
162+
scores.emplace_back(grid[i][j], i, j);
163+
sort(scores.begin(), scores.end());
164+
vector<int> dirs = {-1, 0, 1, 0, -1};
165+
while (find(0) != find(m * n - 1))
166+
{
167+
auto [score, i, j] = scores.back();
168+
scores.pop_back();
169+
ans = min(ans, score);
170+
vis[i][j] = true;
171+
for (int k = 0; k < 4; ++k)
172+
{
173+
int x = i + dirs[k], y = j + dirs[k + 1];
174+
if (x >= 0 && x < m && y >= 0 && y < n && vis[x][y])
175+
p[find(x * n + y)] = find(i * n + j);
176+
}
177+
}
178+
return ans;
179+
}
180+
181+
int find(int x) {
182+
if (p[x] != x) p[x] = find(p[x]);
183+
return p[x];
184+
}
185+
};
186+
```
71187
188+
### **Go**
189+
190+
```go
191+
func maximumMinimumPath(grid [][]int) int {
192+
m, n := len(grid), len(grid[0])
193+
p := make([]int, m*n)
194+
for i := range p {
195+
p[i] = i
196+
}
197+
var find func(x int) int
198+
find = func(x int) int {
199+
if p[x] != x {
200+
p[x] = find(p[x])
201+
}
202+
return p[x]
203+
}
204+
vis := make([][]bool, m)
205+
var scores [][]int
206+
for i := range vis {
207+
vis[i] = make([]bool, n)
208+
for j := range grid[i] {
209+
scores = append(scores, []int{grid[i][j], i, j})
210+
}
211+
}
212+
sort.Slice(scores, func(i, j int) bool {
213+
return scores[i][0] > scores[j][0]
214+
})
215+
vis[0][0] = true
216+
vis[m-1][n-1] = true
217+
dirs := []int{-1, 0, 1, 0, -1}
218+
ans := min(grid[0][0], grid[m-1][n-1])
219+
for find(0) != find(m*n-1) {
220+
t := scores[0]
221+
scores = scores[1:]
222+
score, i, j := t[0], t[1], t[2]
223+
vis[i][j] = true
224+
ans = min(ans, score)
225+
for k := 0; k < 4; k++ {
226+
x, y := i+dirs[k], j+dirs[k+1]
227+
if x >= 0 && x < m && y >= 0 && y < n && vis[x][y] {
228+
p[find(x*n+y)] = find(i*n + j)
229+
}
230+
}
231+
}
232+
return ans
233+
}
234+
235+
func min(a, b int) int {
236+
if a < b {
237+
return a
238+
}
239+
return b
240+
}
72241
```
73242

74243
### **...**

‎solution/1100-1199/1102.Path With Maximum Minimum Value/README_EN.md

Lines changed: 162 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,174 @@ The path with the maximum score is highlighted in yellow.
6464
### **Python3**
6565

6666
```python
67-
67+
class Solution:
68+
def maximumMinimumPath(self, grid: List[List[int]]) -> int:
69+
def find(x):
70+
if p[x] != x:
71+
p[x] = find(p[x])
72+
return p[x]
73+
74+
m, n = len(grid), len(grid[0])
75+
p = list(range(m * n))
76+
ans = min(grid[0][0], grid[-1][-1])
77+
vis = {(0, 0), (m - 1, n - 1)}
78+
scores = [[grid[i][j], i, j] for i in range(m) for j in range(n)]
79+
scores.sort()
80+
while find(0) != find(m * n - 1):
81+
score, i, j = scores.pop()
82+
ans = min(ans, score)
83+
vis.add((i, j))
84+
for a, b in [[0, 1], [0, -1], [1, 0], [-1, 0]]:
85+
x, y = i + a, j + b
86+
if 0 <= x < m and 0 <= y < n and (x, y) in vis:
87+
p[find(x * n + y)] = find(i * n + j)
88+
return ans
6889
```
6990

7091
### **Java**
7192

7293
```java
94+
class Solution {
95+
private int[] p;
96+
97+
public int maximumMinimumPath(int[][] grid) {
98+
int m = grid.length;
99+
int n = grid[0].length;
100+
p = new int[m * n];
101+
for (int i = 0; i < p.length; ++i) {
102+
p[i] = i;
103+
}
104+
int ans = Math.min(grid[0][0], grid[m - 1][n - 1]);
105+
Set<Integer> vis = new HashSet<>(Arrays.asList(0, m * n - 1));
106+
List<int[]> scores = new ArrayList<>();
107+
for (int i = 0; i < m; ++i) {
108+
for (int j = 0; j < n; ++j) {
109+
scores.add(new int[]{grid[i][j], i, j});
110+
}
111+
}
112+
scores.sort(Comparator.comparingInt(a -> a[0]));
113+
int[] dirs = {-1, 0, 1, 0, -1};
114+
while (find(0) != find(m * n - 1)) {
115+
int[] t = scores.remove(scores.size() - 1);
116+
int score = t[0], i = t[1], j = t[2];
117+
ans = Math.min(ans, score);
118+
vis.add(i * n + j);
119+
for (int k = 0; k < 4; ++k) {
120+
int x = i + dirs[k], y = j + dirs[k + 1];
121+
if (x >= 0 && x < m && y >= 0 && y < n && vis.contains(x * n + y)) {
122+
p[find(x * n + y)] = find(i * n + j);
123+
}
124+
}
125+
}
126+
return ans;
127+
}
128+
129+
private int find(int x) {
130+
if (p[x] != x) {
131+
p[x] = find(p[x]);
132+
}
133+
return p[x];
134+
}
135+
}
136+
```
137+
138+
### **C++**
139+
140+
```cpp
141+
class Solution {
142+
public:
143+
vector<int> p;
144+
145+
int maximumMinimumPath(vector<vector<int>>& grid) {
146+
int m = grid.size(), n = grid[0].size();
147+
p.resize(m * n);
148+
for (int i = 0; i < p.size(); ++i) p[i] = i;
149+
int ans = min(grid[0][0], grid[m - 1][n - 1]);
150+
vector<vector<bool>> vis(m, vector<bool>(n));
151+
vis[0][0] = true;
152+
vis[m - 1][n - 1] = true;
153+
vector<tuple<int, int, int>> scores;
154+
for (int i = 0; i < m; ++i)
155+
for (int j = 0; j < n; ++j)
156+
scores.emplace_back(grid[i][j], i, j);
157+
sort(scores.begin(), scores.end());
158+
vector<int> dirs = {-1, 0, 1, 0, -1};
159+
while (find(0) != find(m * n - 1))
160+
{
161+
auto [score, i, j] = scores.back();
162+
scores.pop_back();
163+
ans = min(ans, score);
164+
vis[i][j] = true;
165+
for (int k = 0; k < 4; ++k)
166+
{
167+
int x = i + dirs[k], y = j + dirs[k + 1];
168+
if (x >= 0 && x < m && y >= 0 && y < n && vis[x][y])
169+
p[find(x * n + y)] = find(i * n + j);
170+
}
171+
}
172+
return ans;
173+
}
174+
175+
int find(int x) {
176+
if (p[x] != x) p[x] = find(p[x]);
177+
return p[x];
178+
}
179+
};
180+
```
73181
182+
### **Go**
183+
184+
```go
185+
func maximumMinimumPath(grid [][]int) int {
186+
m, n := len(grid), len(grid[0])
187+
p := make([]int, m*n)
188+
for i := range p {
189+
p[i] = i
190+
}
191+
var find func(x int) int
192+
find = func(x int) int {
193+
if p[x] != x {
194+
p[x] = find(p[x])
195+
}
196+
return p[x]
197+
}
198+
vis := make([][]bool, m)
199+
var scores [][]int
200+
for i := range vis {
201+
vis[i] = make([]bool, n)
202+
for j := range grid[i] {
203+
scores = append(scores, []int{grid[i][j], i, j})
204+
}
205+
}
206+
sort.Slice(scores, func(i, j int) bool {
207+
return scores[i][0] > scores[j][0]
208+
})
209+
vis[0][0] = true
210+
vis[m-1][n-1] = true
211+
dirs := []int{-1, 0, 1, 0, -1}
212+
ans := min(grid[0][0], grid[m-1][n-1])
213+
for find(0) != find(m*n-1) {
214+
t := scores[0]
215+
scores = scores[1:]
216+
score, i, j := t[0], t[1], t[2]
217+
vis[i][j] = true
218+
ans = min(ans, score)
219+
for k := 0; k < 4; k++ {
220+
x, y := i+dirs[k], j+dirs[k+1]
221+
if x >= 0 && x < m && y >= 0 && y < n && vis[x][y] {
222+
p[find(x*n+y)] = find(i*n + j)
223+
}
224+
}
225+
}
226+
return ans
227+
}
228+
229+
func min(a, b int) int {
230+
if a < b {
231+
return a
232+
}
233+
return b
234+
}
74235
```
75236

76237
### **...**

0 commit comments

Comments
 (0)