Skip to content

Commit 4f40181

Browse files
authored
feat: add solutions to lc problem: No.1102 (doocs#2050)
No.1102.Path With Maximum Minimum Value
1 parent 1fc838e commit 4f40181

File tree

5 files changed

+555
-51
lines changed

5 files changed

+555
-51
lines changed

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

Lines changed: 209 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -76,7 +76,7 @@
7676
```python
7777
class Solution:
7878
def maximumMinimumPath(self, grid: List[List[int]]) -> int:
79-
def find(x):
79+
def find(x: int) -> int:
8080
if p[x] != x:
8181
p[x] = find(p[x])
8282
return p[x]
@@ -86,39 +86,43 @@ class Solution:
8686
q = [(v, i, j) for i, row in enumerate(grid) for j, v in enumerate(row)]
8787
q.sort()
8888
ans = 0
89-
vis = set()
9089
dirs = (-1, 0, 1, 0, -1)
90+
vis = set()
9191
while find(0) != find(m * n - 1):
9292
v, i, j = q.pop()
9393
ans = v
9494
vis.add((i, j))
9595
for a, b in pairwise(dirs):
9696
x, y = i + a, j + b
97-
if 0 <= x < m and 0 <= y < n and (x, y) in vis:
98-
p[find(x * n + y)] = find(i * n + j)
97+
if (x, y) in vis:
98+
p[find(i * n + j)] = find(x * n + y)
9999
return ans
100100
```
101101

102102
```python
103103
class UnionFind:
104+
__slots__ = ("p", "size")
105+
104106
def __init__(self, n):
105107
self.p = list(range(n))
106108
self.size = [1] * n
107109

108-
def find(self, x):
110+
def find(self, x: int) -> int:
109111
if self.p[x] != x:
110112
self.p[x] = self.find(self.p[x])
111113
return self.p[x]
112114

113-
def union(self, a, b):
115+
def union(self, a: int, b: int) -> bool:
114116
pa, pb = self.find(a), self.find(b)
115-
if pa != pb:
116-
if self.size[pa] > self.size[pb]:
117-
self.p[pb] = pa
118-
self.size[pa] += self.size[pb]
119-
else:
120-
self.p[pa] = pb
121-
self.size[pb] += self.size[pa]
117+
if pa == pb:
118+
return False
119+
if self.size[pa] > self.size[pb]:
120+
self.p[pb] = pa
121+
self.size[pa] += self.size[pb]
122+
else:
123+
self.p[pa] = pb
124+
self.size[pb] += self.size[pa]
125+
return True
122126

123127

124128
class Solution:
@@ -136,7 +140,7 @@ class Solution:
136140
vis.add((i, j))
137141
for a, b in pairwise(dirs):
138142
x, y = i + a, j + b
139-
if 0 <= x < m and 0 <= y < n and (x, y) in vis:
143+
if (x, y) in vis:
140144
uf.union(x * n + y, i * n + j)
141145
return ans
142146
```
@@ -467,6 +471,197 @@ func maximumMinimumPath(grid [][]int) (ans int) {
467471
}
468472
```
469473

474+
### **TypeScript**
475+
476+
```ts
477+
function maximumMinimumPath(grid: number[][]): number {
478+
const m = grid.length;
479+
const n = grid[0].length;
480+
const p: number[] = Array(m * n)
481+
.fill(0)
482+
.map((_, i) => i);
483+
const q: number[][] = [];
484+
for (let i = 0; i < m; ++i) {
485+
for (let j = 0; j < n; ++j) {
486+
q.push([grid[i][j], i, j]);
487+
}
488+
}
489+
q.sort((a, b) => b[0] - a[0]);
490+
const find = (x: number): number => {
491+
if (p[x] !== x) {
492+
p[x] = find(p[x]);
493+
}
494+
return p[x];
495+
};
496+
const dirs: number[] = [-1, 0, 1, 0, -1];
497+
const vis: boolean[][] = Array(m)
498+
.fill(0)
499+
.map(() => Array(n).fill(false));
500+
let ans = 0;
501+
for (let k = 0; find(0) !== find(m * n - 1); ++k) {
502+
const [t, i, j] = q[k];
503+
ans = t;
504+
vis[i][j] = true;
505+
for (let d = 0; d < 4; ++d) {
506+
const [x, y] = [i + dirs[d], j + dirs[d + 1]];
507+
if (x >= 0 && x < m && y >= 0 && y < n && vis[x][y]) {
508+
p[find(i * n + j)] = find(x * n + y);
509+
}
510+
}
511+
}
512+
return ans;
513+
}
514+
```
515+
516+
```ts
517+
class UnionFind {
518+
private p: number[];
519+
private size: number[];
520+
521+
constructor(n: number) {
522+
this.p = Array(n)
523+
.fill(0)
524+
.map((_, i) => i);
525+
this.size = Array(n).fill(1);
526+
}
527+
528+
find(x: number): number {
529+
if (this.p[x] !== x) {
530+
this.p[x] = this.find(this.p[x]);
531+
}
532+
return this.p[x];
533+
}
534+
535+
union(a: number, b: number): boolean {
536+
const pa = this.find(a);
537+
const pb = this.find(b);
538+
if (pa === pb) {
539+
return false;
540+
}
541+
if (this.size[pa] > this.size[pb]) {
542+
this.p[pb] = pa;
543+
this.size[pa] += this.size[pb];
544+
} else {
545+
this.p[pa] = pb;
546+
this.size[pb] += this.size[pa];
547+
}
548+
return true;
549+
}
550+
}
551+
552+
function maximumMinimumPath(grid: number[][]): number {
553+
const m = grid.length;
554+
const n = grid[0].length;
555+
const q: number[][] = [];
556+
for (let i = 0; i < m; ++i) {
557+
for (let j = 0; j < n; ++j) {
558+
q.push([grid[i][j], i, j]);
559+
}
560+
}
561+
q.sort((a, b) => b[0] - a[0]);
562+
const dirs: number[] = [-1, 0, 1, 0, -1];
563+
const vis: boolean[][] = Array(m)
564+
.fill(0)
565+
.map(() => Array(n).fill(false));
566+
let ans = 0;
567+
const uf = new UnionFind(m * n);
568+
for (let k = 0; uf.find(0) !== uf.find(m * n - 1); ++k) {
569+
const [t, i, j] = q[k];
570+
ans = t;
571+
vis[i][j] = true;
572+
for (let d = 0; d < 4; ++d) {
573+
const [x, y] = [i + dirs[d], j + dirs[d + 1]];
574+
if (x >= 0 && x < m && y >= 0 && y < n && vis[x][y]) {
575+
uf.union(i * n + j, x * n + y);
576+
}
577+
}
578+
}
579+
return ans;
580+
}
581+
```
582+
583+
### **Rust**
584+
585+
```rust
586+
struct UnionFind {
587+
p: Vec<usize>,
588+
size: Vec<usize>,
589+
}
590+
591+
impl UnionFind {
592+
fn new(n: usize) -> Self {
593+
let p: Vec<usize> = (0..n).collect();
594+
let size = vec![1; n];
595+
UnionFind { p, size }
596+
}
597+
598+
fn find(&mut self, x: usize) -> usize {
599+
if self.p[x] != x {
600+
self.p[x] = self.find(self.p[x]);
601+
}
602+
self.p[x]
603+
}
604+
605+
fn union(&mut self, a: usize, b: usize) {
606+
let pa = self.find(a);
607+
let pb = self.find(b);
608+
if pa != pb {
609+
if self.size[pa] > self.size[pb] {
610+
self.p[pb] = pa;
611+
self.size[pa] += self.size[pb];
612+
} else {
613+
self.p[pa] = pb;
614+
self.size[pb] += self.size[pa];
615+
}
616+
}
617+
}
618+
}
619+
620+
impl Solution {
621+
pub fn maximum_minimum_path(grid: Vec<Vec<i32>>) -> i32 {
622+
let m = grid.len();
623+
let n = grid[0].len();
624+
let mut uf = UnionFind::new(m * n);
625+
let mut q: Vec<Vec<i32>> = Vec::new();
626+
627+
for i in 0..m {
628+
for j in 0..n {
629+
q.push(vec![grid[i][j], i as i32, j as i32]);
630+
}
631+
}
632+
633+
q.sort_by(|a, b| b[0].cmp(&a[0]));
634+
635+
let mut vis: Vec<Vec<bool>> = vec![vec![false; n]; m];
636+
let dirs: [i32; 5] = [-1, 0, 1, 0, -1];
637+
let mut ans = 0;
638+
for k in 0..q.len() {
639+
if uf.find(0) == uf.find(m * n - 1) {
640+
break;
641+
}
642+
let t = &q[k];
643+
let (v, i, j) = (t[0], t[1] as usize, t[2] as usize);
644+
ans = v;
645+
vis[i][j] = true;
646+
for d in 0..4 {
647+
let x = (i as i32) + dirs[d];
648+
let y = (j as i32) + dirs[d + 1];
649+
if
650+
x >= 0 &&
651+
x < (m as i32) &&
652+
y >= 0 &&
653+
y < (n as i32) &&
654+
vis[x as usize][y as usize]
655+
{
656+
uf.union((x as usize) * n + (y as usize), i * n + j);
657+
}
658+
}
659+
}
660+
ans
661+
}
662+
}
663+
```
664+
470665
### **...**
471666

472667
```

0 commit comments

Comments
 (0)