Skip to content

Commit 245d8d4

Browse files
yanglbmeyanglbme
committedJun 17, 2023
feat: add solutions to lc problem: No.1254
No.1254.Number of Closed Islands
·
v0.2.0
1 parent 6027235 commit 245d8d4

File tree

5 files changed

+480
-22
lines changed

5 files changed

+480
-22
lines changed
 

‎solution/1200-1299/1254.Number of Closed Islands/README.md

+204-4
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,7 @@
8686
```python
8787
class Solution:
8888
def closedIsland(self, grid: List[List[int]]) -> int:
89-
def dfs(i, j):
89+
def dfs(i: int, j: int) -> int:
9090
res = int(0 < i < m - 1 and 0 < j < n - 1)
9191
grid[i][j] = 1
9292
for a, b in pairwise(dirs):
@@ -102,16 +102,16 @@ class Solution:
102102

103103
```python
104104
class UnionFind:
105-
def __init__(self, n):
105+
def __init__(self, n: int):
106106
self.p = list(range(n))
107107
self.size = [1] * n
108108

109-
def find(self, x):
109+
def find(self, x: int) -> int:
110110
if self.p[x] != x:
111111
self.p[x] = self.find(self.p[x])
112112
return self.p[x]
113113

114-
def union(self, a, b):
114+
def union(self, a: int, b: int):
115115
pa, pb = self.find(a), self.find(b)
116116
if pa != pb:
117117
if self.size[pa] > self.size[pb]:
@@ -439,6 +439,206 @@ func closedIsland(grid [][]int) (ans int) {
439439
}
440440
```
441441

442+
### **TypeScript**
443+
444+
```ts
445+
function closedIsland(grid: number[][]): number {
446+
const m = grid.length;
447+
const n = grid[0].length;
448+
const dirs = [-1, 0, 1, 0, -1];
449+
const dfs = (i: number, j: number): number => {
450+
let res = i > 0 && j > 0 && i < m - 1 && j < n - 1 ? 1 : 0;
451+
grid[i][j] = 1;
452+
for (let k = 0; k < 4; ++k) {
453+
const [x, y] = [i + dirs[k], j + dirs[k + 1]];
454+
if (x >= 0 && y >= 0 && x < m && y < n && grid[x][y] === 0) {
455+
res &= dfs(x, y);
456+
}
457+
}
458+
return res;
459+
};
460+
let ans = 0;
461+
for (let i = 0; i < m; ++i) {
462+
for (let j = 0; j < n; j++) {
463+
if (grid[i][j] === 0) {
464+
ans += dfs(i, j);
465+
}
466+
}
467+
}
468+
return ans;
469+
}
470+
```
471+
472+
```ts
473+
function closedIsland(grid: number[][]): number {
474+
const m = grid.length;
475+
const n = grid[0].length;
476+
const uf = new UnionFind(m * n + 1);
477+
for (let i = 0; i < m; ++i) {
478+
for (let j = 0; j < n; ++j) {
479+
if (i === 0 || i === m - 1 || j === 0 || j === n - 1) {
480+
uf.union(i * n + j, m * n);
481+
}
482+
if (grid[i][j] === 0) {
483+
if (i + 1 < m && grid[i + 1][j] === 0) {
484+
uf.union(i * n + j, (i + 1) * n + j);
485+
}
486+
if (j + 1 < n && grid[i][j + 1] === 0) {
487+
uf.union(i * n + j, i * n + j + 1);
488+
}
489+
}
490+
}
491+
}
492+
let ans = 0;
493+
for (let i = 0; i < m; ++i) {
494+
for (let j = 0; j < n; j++) {
495+
if (grid[i][j] === 0 && uf.find(i * n + j) === i * n + j) {
496+
++ans;
497+
}
498+
}
499+
}
500+
return ans;
501+
}
502+
503+
class UnionFind {
504+
private p: number[];
505+
private size: number[];
506+
507+
constructor(n: number) {
508+
this.p = Array(n)
509+
.fill(0)
510+
.map((_, i) => i);
511+
this.size = Array(n).fill(1);
512+
}
513+
514+
find(x: number): number {
515+
if (this.p[x] !== x) {
516+
this.p[x] = this.find(this.p[x]);
517+
}
518+
return this.p[x];
519+
}
520+
521+
union(a: number, b: number): void {
522+
const [pa, pb] = [this.find(a), this.find(b)];
523+
if (pa === pb) {
524+
return;
525+
}
526+
if (this.size[pa] > this.size[pb]) {
527+
this.p[pb] = pa;
528+
this.size[pa] += this.size[pb];
529+
} else {
530+
this.p[pa] = pb;
531+
this.size[pb] += this.size[pa];
532+
}
533+
}
534+
}
535+
```
536+
537+
### **C#**
538+
539+
```cs
540+
public class Solution {
541+
private int m;
542+
private int n;
543+
private int[][] grid;
544+
545+
public int ClosedIsland(int[][] grid) {
546+
m = grid.Length;
547+
n = grid[0].Length;
548+
this.grid = grid;
549+
int ans = 0;
550+
for (int i = 0; i < m; ++i) {
551+
for (int j = 0; j < n; ++j) {
552+
if (grid[i][j] == 0) {
553+
ans += dfs(i, j);
554+
}
555+
}
556+
}
557+
return ans;
558+
}
559+
560+
private int dfs(int i, int j) {
561+
int res = i > 0 && i < m - 1 && j > 0 && j < n - 1 ? 1 : 0;
562+
grid[i][j] = 1;
563+
int[] dirs = {-1, 0, 1, 0, -1};
564+
for (int k = 0; k < 4; ++k) {
565+
int x = i + dirs[k], y = j + dirs[k + 1];
566+
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0) {
567+
res &= dfs(x, y);
568+
}
569+
}
570+
return res;
571+
}
572+
}
573+
```
574+
575+
```cs
576+
class UnionFind {
577+
private int[] p;
578+
private int[] size;
579+
580+
public UnionFind(int n) {
581+
p = new int[n];
582+
size = new int[n];
583+
for (int i = 0; i < n; ++i) {
584+
p[i] = i;
585+
size[i] = 1;
586+
}
587+
}
588+
589+
public int find(int x) {
590+
if (p[x] != x) {
591+
p[x] = find(p[x]);
592+
}
593+
return p[x];
594+
}
595+
596+
public void union(int a, int b) {
597+
int pa = find(a), pb = find(b);
598+
if (pa != pb) {
599+
if (size[pa] > size[pb]) {
600+
p[pb] = pa;
601+
size[pa] += size[pb];
602+
} else {
603+
p[pa] = pb;
604+
size[pb] += size[pa];
605+
}
606+
}
607+
}
608+
}
609+
610+
public class Solution {
611+
public int ClosedIsland(int[][] grid) {
612+
int m = grid.Length, n = grid[0].Length;
613+
UnionFind uf = new UnionFind(m * n + 1);
614+
for (int i = 0; i < m; ++i) {
615+
for (int j = 0; j < n; ++j) {
616+
if (i == 0 || i == m - 1 || j == 0 || j == n - 1) {
617+
uf.union(i * n + j, m * n);
618+
}
619+
if (grid[i][j] == 0) {
620+
if (i + 1 < m && grid[i + 1][j] == 0) {
621+
uf.union(i * n + j, (i + 1) * n + j);
622+
}
623+
if (j + 1 < n && grid[i][j + 1] == 0) {
624+
uf.union(i * n + j, i * n + j + 1);
625+
}
626+
}
627+
}
628+
}
629+
int ans = 0;
630+
for (int i = 0; i < m; ++i) {
631+
for (int j = 0; j < n; ++j) {
632+
if (grid[i][j] == 0 && uf.find(i * n + j) == i * n + j) {
633+
++ans;
634+
}
635+
}
636+
}
637+
return ans;
638+
}
639+
}
640+
```
641+
442642
### **...**
443643

444644
```

‎solution/1200-1299/1254.Number of Closed Islands/README_EN.md

+204-4
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ Union find.
6060
```python
6161
class Solution:
6262
def closedIsland(self, grid: List[List[int]]) -> int:
63-
def dfs(i, j):
63+
def dfs(i: int, j: int) -> int:
6464
res = int(0 < i < m - 1 and 0 < j < n - 1)
6565
grid[i][j] = 1
6666
for a, b in pairwise(dirs):
@@ -76,16 +76,16 @@ class Solution:
7676

7777
```python
7878
class UnionFind:
79-
def __init__(self, n):
79+
def __init__(self, n: int):
8080
self.p = list(range(n))
8181
self.size = [1] * n
8282

83-
def find(self, x):
83+
def find(self, x: int) -> int:
8484
if self.p[x] != x:
8585
self.p[x] = self.find(self.p[x])
8686
return self.p[x]
8787

88-
def union(self, a, b):
88+
def union(self, a: int, b: int):
8989
pa, pb = self.find(a), self.find(b)
9090
if pa != pb:
9191
if self.size[pa] > self.size[pb]:
@@ -411,6 +411,206 @@ func closedIsland(grid [][]int) (ans int) {
411411
}
412412
```
413413

414+
### **TypeScript**
415+
416+
```ts
417+
function closedIsland(grid: number[][]): number {
418+
const m = grid.length;
419+
const n = grid[0].length;
420+
const dirs = [-1, 0, 1, 0, -1];
421+
const dfs = (i: number, j: number): number => {
422+
let res = i > 0 && j > 0 && i < m - 1 && j < n - 1 ? 1 : 0;
423+
grid[i][j] = 1;
424+
for (let k = 0; k < 4; ++k) {
425+
const [x, y] = [i + dirs[k], j + dirs[k + 1]];
426+
if (x >= 0 && y >= 0 && x < m && y < n && grid[x][y] === 0) {
427+
res &= dfs(x, y);
428+
}
429+
}
430+
return res;
431+
};
432+
let ans = 0;
433+
for (let i = 0; i < m; ++i) {
434+
for (let j = 0; j < n; j++) {
435+
if (grid[i][j] === 0) {
436+
ans += dfs(i, j);
437+
}
438+
}
439+
}
440+
return ans;
441+
}
442+
```
443+
444+
```ts
445+
function closedIsland(grid: number[][]): number {
446+
const m = grid.length;
447+
const n = grid[0].length;
448+
const uf = new UnionFind(m * n + 1);
449+
for (let i = 0; i < m; ++i) {
450+
for (let j = 0; j < n; ++j) {
451+
if (i === 0 || i === m - 1 || j === 0 || j === n - 1) {
452+
uf.union(i * n + j, m * n);
453+
}
454+
if (grid[i][j] === 0) {
455+
if (i + 1 < m && grid[i + 1][j] === 0) {
456+
uf.union(i * n + j, (i + 1) * n + j);
457+
}
458+
if (j + 1 < n && grid[i][j + 1] === 0) {
459+
uf.union(i * n + j, i * n + j + 1);
460+
}
461+
}
462+
}
463+
}
464+
let ans = 0;
465+
for (let i = 0; i < m; ++i) {
466+
for (let j = 0; j < n; j++) {
467+
if (grid[i][j] === 0 && uf.find(i * n + j) === i * n + j) {
468+
++ans;
469+
}
470+
}
471+
}
472+
return ans;
473+
}
474+
475+
class UnionFind {
476+
private p: number[];
477+
private size: number[];
478+
479+
constructor(n: number) {
480+
this.p = Array(n)
481+
.fill(0)
482+
.map((_, i) => i);
483+
this.size = Array(n).fill(1);
484+
}
485+
486+
find(x: number): number {
487+
if (this.p[x] !== x) {
488+
this.p[x] = this.find(this.p[x]);
489+
}
490+
return this.p[x];
491+
}
492+
493+
union(a: number, b: number): void {
494+
const [pa, pb] = [this.find(a), this.find(b)];
495+
if (pa === pb) {
496+
return;
497+
}
498+
if (this.size[pa] > this.size[pb]) {
499+
this.p[pb] = pa;
500+
this.size[pa] += this.size[pb];
501+
} else {
502+
this.p[pa] = pb;
503+
this.size[pb] += this.size[pa];
504+
}
505+
}
506+
}
507+
```
508+
509+
### **C#**
510+
511+
```cs
512+
public class Solution {
513+
private int m;
514+
private int n;
515+
private int[][] grid;
516+
517+
public int ClosedIsland(int[][] grid) {
518+
m = grid.Length;
519+
n = grid[0].Length;
520+
this.grid = grid;
521+
int ans = 0;
522+
for (int i = 0; i < m; ++i) {
523+
for (int j = 0; j < n; ++j) {
524+
if (grid[i][j] == 0) {
525+
ans += dfs(i, j);
526+
}
527+
}
528+
}
529+
return ans;
530+
}
531+
532+
private int dfs(int i, int j) {
533+
int res = i > 0 && i < m - 1 && j > 0 && j < n - 1 ? 1 : 0;
534+
grid[i][j] = 1;
535+
int[] dirs = {-1, 0, 1, 0, -1};
536+
for (int k = 0; k < 4; ++k) {
537+
int x = i + dirs[k], y = j + dirs[k + 1];
538+
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0) {
539+
res &= dfs(x, y);
540+
}
541+
}
542+
return res;
543+
}
544+
}
545+
```
546+
547+
```cs
548+
class UnionFind {
549+
private int[] p;
550+
private int[] size;
551+
552+
public UnionFind(int n) {
553+
p = new int[n];
554+
size = new int[n];
555+
for (int i = 0; i < n; ++i) {
556+
p[i] = i;
557+
size[i] = 1;
558+
}
559+
}
560+
561+
public int find(int x) {
562+
if (p[x] != x) {
563+
p[x] = find(p[x]);
564+
}
565+
return p[x];
566+
}
567+
568+
public void union(int a, int b) {
569+
int pa = find(a), pb = find(b);
570+
if (pa != pb) {
571+
if (size[pa] > size[pb]) {
572+
p[pb] = pa;
573+
size[pa] += size[pb];
574+
} else {
575+
p[pa] = pb;
576+
size[pb] += size[pa];
577+
}
578+
}
579+
}
580+
}
581+
582+
public class Solution {
583+
public int ClosedIsland(int[][] grid) {
584+
int m = grid.Length, n = grid[0].Length;
585+
UnionFind uf = new UnionFind(m * n + 1);
586+
for (int i = 0; i < m; ++i) {
587+
for (int j = 0; j < n; ++j) {
588+
if (i == 0 || i == m - 1 || j == 0 || j == n - 1) {
589+
uf.union(i * n + j, m * n);
590+
}
591+
if (grid[i][j] == 0) {
592+
if (i + 1 < m && grid[i + 1][j] == 0) {
593+
uf.union(i * n + j, (i + 1) * n + j);
594+
}
595+
if (j + 1 < n && grid[i][j + 1] == 0) {
596+
uf.union(i * n + j, i * n + j + 1);
597+
}
598+
}
599+
}
600+
}
601+
int ans = 0;
602+
for (int i = 0; i < m; ++i) {
603+
for (int j = 0; j < n; ++j) {
604+
if (grid[i][j] == 0 && uf.find(i * n + j) == i * n + j) {
605+
++ans;
606+
}
607+
}
608+
}
609+
return ans;
610+
}
611+
}
612+
```
613+
414614
### **...**
415615

416616
```

‎solution/1200-1299/1254.Number of Closed Islands/Solution.cs

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
public class Solution {
2+
private int m;
3+
private int n;
4+
private int[][] grid;
5+
6+
public int ClosedIsland(int[][] grid) {
7+
m = grid.Length;
8+
n = grid[0].Length;
9+
this.grid = grid;
10+
int ans = 0;
11+
for (int i = 0; i < m; ++i) {
12+
for (int j = 0; j < n; ++j) {
13+
if (grid[i][j] == 0) {
14+
ans += dfs(i, j);
15+
}
16+
}
17+
}
18+
return ans;
19+
}
20+
21+
private int dfs(int i, int j) {
22+
int res = i > 0 && i < m - 1 && j > 0 && j < n - 1 ? 1 : 0;
23+
grid[i][j] = 1;
24+
int[] dirs = {-1, 0, 1, 0, -1};
25+
for (int k = 0; k < 4; ++k) {
26+
int x = i + dirs[k], y = j + dirs[k + 1];
27+
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 0) {
28+
res &= dfs(x, y);
29+
}
30+
}
31+
return res;
32+
}
33+
}

‎solution/1200-1299/1254.Number of Closed Islands/Solution.py

+14-14
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
1-
class Solution:
2-
def closedIsland(self, grid: List[List[int]]) -> int:
3-
def dfs(i, j):
4-
res = int(0 < i < m - 1 and 0 < j < n - 1)
5-
grid[i][j] = 1
6-
for a, b in pairwise(dirs):
7-
x, y = i + a, j + b
8-
if 0 <= x < m and 0 <= y < n and grid[x][y] == 0:
9-
res &= dfs(x, y)
10-
return res
11-
12-
m, n = len(grid), len(grid[0])
13-
dirs = (-1, 0, 1, 0, -1)
14-
return sum(grid[i][j] == 0 and dfs(i, j) for i in range(m) for j in range(n))
1+
class Solution:
2+
def closedIsland(self, grid: List[List[int]]) -> int:
3+
def dfs(i: int, j: int) -> int:
4+
res = int(0 < i < m - 1 and 0 < j < n - 1)
5+
grid[i][j] = 1
6+
for a, b in pairwise(dirs):
7+
x, y = i + a, j + b
8+
if 0 <= x < m and 0 <= y < n and grid[x][y] == 0:
9+
res &= dfs(x, y)
10+
return res
11+
12+
m, n = len(grid), len(grid[0])
13+
dirs = (-1, 0, 1, 0, -1)
14+
return sum(grid[i][j] == 0 and dfs(i, j) for i in range(m) for j in range(n))

‎solution/1200-1299/1254.Number of Closed Islands/Solution.ts

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
function closedIsland(grid: number[][]): number {
2+
const m = grid.length;
3+
const n = grid[0].length;
4+
const dirs = [-1, 0, 1, 0, -1];
5+
const dfs = (i: number, j: number): number => {
6+
let res = i > 0 && j > 0 && i < m - 1 && j < n - 1 ? 1 : 0;
7+
grid[i][j] = 1;
8+
for (let k = 0; k < 4; ++k) {
9+
const [x, y] = [i + dirs[k], j + dirs[k + 1]];
10+
if (x >= 0 && y >= 0 && x < m && y < n && grid[x][y] === 0) {
11+
res &= dfs(x, y);
12+
}
13+
}
14+
return res;
15+
};
16+
let ans = 0;
17+
for (let i = 0; i < m; ++i) {
18+
for (let j = 0; j < n; j++) {
19+
if (grid[i][j] === 0) {
20+
ans += dfs(i, j);
21+
}
22+
}
23+
}
24+
return ans;
25+
}

0 commit comments

Comments
 (0)
Please sign in to comment.