76
76
``` python
77
77
class Solution :
78
78
def maximumMinimumPath (self , grid : List[List[int ]]) -> int :
79
- def find (x ) :
79
+ def find (x : int ) -> int :
80
80
if p[x] != x:
81
81
p[x] = find(p[x])
82
82
return p[x]
@@ -86,39 +86,43 @@ class Solution:
86
86
q = [(v, i, j) for i, row in enumerate (grid) for j, v in enumerate (row)]
87
87
q.sort()
88
88
ans = 0
89
- vis = set ()
90
89
dirs = (- 1 , 0 , 1 , 0 , - 1 )
90
+ vis = set ()
91
91
while find(0 ) != find(m * n - 1 ):
92
92
v, i, j = q.pop()
93
93
ans = v
94
94
vis.add((i, j))
95
95
for a, b in pairwise(dirs):
96
96
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 )
99
99
return ans
100
100
```
101
101
102
102
``` python
103
103
class UnionFind :
104
+ __slots__ = (" p" , " size" )
105
+
104
106
def __init__ (self , n ):
105
107
self .p = list (range (n))
106
108
self .size = [1 ] * n
107
109
108
- def find (self , x ) :
110
+ def find (self , x : int ) -> int :
109
111
if self .p[x] != x:
110
112
self .p[x] = self .find(self .p[x])
111
113
return self .p[x]
112
114
113
- def union (self , a , b ) :
115
+ def union (self , a : int , b : int ) -> bool :
114
116
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
122
126
123
127
124
128
class Solution :
@@ -136,7 +140,7 @@ class Solution:
136
140
vis.add((i, j))
137
141
for a, b in pairwise(dirs):
138
142
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:
140
144
uf.union(x * n + y, i * n + j)
141
145
return ans
142
146
```
@@ -467,6 +471,197 @@ func maximumMinimumPath(grid [][]int) (ans int) {
467
471
}
468
472
```
469
473
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
+
470
665
### ** ...**
471
666
472
667
```
0 commit comments