[pull] master from youngyangyang04:master

problems/kamacoder/0101.孤岛的总面积.md

@@ -261,10 +261,10 @@ public class Main {
 from collections import deque
 
 # 处理输入
-n, m = list(map(int, input().strip().split()))
+n, m = list(map(int, input().strip()))
 g = []
 for _ in range(n):
-    row = list(map(int, input().strip().split()))
+    row = list(map(int, input().strip()))
     g.append(row)
 
 # 定义四个方向、孤岛面积（遍历完边缘后会被重置）

problems/kamacoder/0102.沉没孤岛.md

@@ -138,9 +138,129 @@ int main() {
 
 ### Java 
 
+```JAVA
+
+import java.util.Scanner;
+
+public class Main {
+    static int[][] dir = { {-1, 0}, {0, -1}, {1, 0}, {0, 1} }; // 保存四个方向
+
+    public static void dfs(int[][] grid, int x, int y) {
+        grid[x][y] = 2;
+        for (int[] d : dir) {
+            int nextX = x + d[0];
+            int nextY = y + d[1];
+            // 超过边界
+            if (nextX < 0 || nextX >= grid.length || nextY < 0 || nextY >= grid[0].length) continue;
+            // 不符合条件，不继续遍历
+            if (grid[nextX][nextY] == 0 || grid[nextX][nextY] == 2) continue;
+            dfs(grid, nextX, nextY);
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int n = scanner.nextInt();
+        int m = scanner.nextInt();
+        int[][] grid = new int[n][m];
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                grid[i][j] = scanner.nextInt();
+            }
+        }
+
+        // 步骤一：
+        // 从左侧边，和右侧边 向中间遍历
+        for (int i = 0; i < n; i++) {
+            if (grid[i][0] == 1) dfs(grid, i, 0);
+            if (grid[i][m - 1] == 1) dfs(grid, i, m - 1);
+        }
+
+        // 从上边和下边 向中间遍历
+        for (int j = 0; j < m; j++) {
+            if (grid[0][j] == 1) dfs(grid, 0, j);
+            if (grid[n - 1][j] == 1) dfs(grid, n - 1, j);
+        }
+
+        // 步骤二、步骤三
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (grid[i][j] == 1) grid[i][j] = 0;
+                if (grid[i][j] == 2) grid[i][j] = 1;
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                System.out.print(grid[i][j] + " ");
+            }
+            System.out.println();
+        }
+
+        scanner.close();
+    }
+}
+
+
+```
+
+
 ### Python
 
-#### 广搜版
+
+```python
+
+def dfs(grid, x, y):
+    grid[x][y] = 2
+    directions = [(-1, 0), (0, -1), (1, 0), (0, 1)]  # 四个方向
+    for dx, dy in directions:
+        nextx, nexty = x + dx, y + dy
+        # 超过边界
+        if nextx < 0 or nextx >= len(grid) or nexty < 0 or nexty >= len(grid[0]):
+            continue
+        # 不符合条件，不继续遍历
+        if grid[nextx][nexty] == 0 or grid[nextx][nexty] == 2:
+            continue
+        dfs(grid, nextx, nexty)
+
+def main():
+    n, m = map(int, input().split())
+    grid = [[int(x) for x in input().split()] for _ in range(n)]
+
+    # 步骤一：
+    # 从左侧边，和右侧边 向中间遍历
+    for i in range(n):
+        if grid[i][0] == 1:
+            dfs(grid, i, 0)
+        if grid[i][m - 1] == 1:
+            dfs(grid, i, m - 1)
+
+    # 从上边和下边 向中间遍历
+    for j in range(m):
+        if grid[0][j] == 1:
+            dfs(grid, 0, j)
+        if grid[n - 1][j] == 1:
+            dfs(grid, n - 1, j)
+
+    # 步骤二、步骤三
+    for i in range(n):
+        for j in range(m):
+            if grid[i][j] == 1:
+                grid[i][j] = 0
+            if grid[i][j] == 2:
+                grid[i][j] = 1
+
+    # 打印结果
+    for row in grid:
+        print(' '.join(map(str, row)))
+
+if __name__ == "__main__":
+    main()
+```
+
+
+ 广搜版
 ```Python
 from collections import deque
 
@@ -194,6 +314,7 @@ for i in range(n):
 
 for row in g:
     print(" ".join(map(str, row)))
+
 ```
 
 

problems/kamacoder/0107.寻找存在的路径.md

@@ -217,8 +217,127 @@ class DisJoint{
 
 ### Python
 
+```python
+
+class UnionFind:
+    def __init__(self, size):
+        self.parent = list(range(size + 1))  # 初始化并查集
+
+    def find(self, u):
+        if self.parent[u] != u:
+            self.parent[u] = self.find(self.parent[u])  # 路径压缩
+        return self.parent[u]
+
+    def union(self, u, v):
+        root_u = self.find(u)
+        root_v = self.find(v)
+        if root_u != root_v:
+            self.parent[root_v] = root_u
+
+    def is_same(self, u, v):
+        return self.find(u) == self.find(v)
+
+
+def main():
+    import sys
+    input = sys.stdin.read
+    data = input().split()
+
+    index = 0
+    n = int(data[index])
+    index += 1
+    m = int(data[index])
+    index += 1
+
+    uf = UnionFind(n)
+
+    for _ in range(m):
+        s = int(data[index])
+        index += 1
+        t = int(data[index])
+        index += 1
+        uf.union(s, t)
+
+    source = int(data[index])
+    index += 1
+    destination = int(data[index])
+
+    if uf.is_same(source, destination):
+        print(1)
+    else:
+        print(0)
+
+if __name__ == "__main__":
+    main()
+
+
+```
+
+
 ### Go
 
+```go
+
+package main
+
+import (
+    "fmt"
+)
+
+const MaxNodes = 101
+
+var n int
+var father [MaxNodes]int
+
+// 初始化并查集
+func initialize() {
+    for i := 1; i <= n; i++ {
+        father[i] = i
+    }
+}
+
+// 并查集里寻根的过程
+func find(u int) int {
+    if u == father[u] {
+        return u
+    }
+    father[u] = find(father[u])
+    return father[u]
+}
+
+// 判断 u 和 v 是否找到同一个根
+func isSame(u, v int) bool {
+    return find(u) == find(v)
+}
+
+// 将 v->u 这条边加入并查集
+func join(u, v int) {
+    rootU := find(u)
+    rootV := find(v)
+    if rootU != rootV {
+        father[rootV] = rootU
+    }
+}
+
+func main() {
+    var m, s, t, source, destination int
+    fmt.Scan(&n, &m)
+    initialize()
+    for i := 0; i < m; i++ {
+        fmt.Scan(&s, &t)
+        join(s, t)
+    }
+    fmt.Scan(&source, &destination)
+    if isSame(source, destination) {
+        fmt.Println(1)
+    } else {
+        fmt.Println(0)
+    }
+}
+
+
+```
+
 ### Rust
 
 ### Javascript