Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 4f40181

Browse files
feat: add solutions to lc problem: No.1102 (#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 and0<= 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 and0<= 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)

AltStyle によって変換されたページ (->オリジナル) /