From a663089383732a56011c1b630c30635265c316a7 Mon Sep 17 00:00:00 2001
From: jjblaack <jjghmyt2022@163.com>
Date: Sat, 5 Oct 2024 18:07:00 +0800
Subject: [PATCH] =?UTF-8?q?=E5=B2=9B=E5=B1=BF=E7=9A=84=E6=9C=80=E5=A4=A7?=
 =?UTF-8?q?=E9=9D=A2=E7=A7=AFjava=E5=AE=9E=E7=8E=B0=EF=BC=88dfs+bfs?=
 =?UTF-8?q?=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../kamacoder/0100.岛屿的最大面积.md   | 116 +++++++++++++++++-
 1 file changed, 115 insertions(+), 1 deletion(-)

diff --git a/problems/kamacoder/0100.岛屿的最大面积.md b/problems/kamacoder/0100.岛屿的最大面积.md
index 51bfc57f..38b98d0e 100644
--- a/problems/kamacoder/0100.岛屿的最大面积.md
+++ b/problems/kamacoder/0100.岛屿的最大面积.md
@@ -223,7 +223,121 @@ public:
 ## 其他语言版本
 
 ### Java 
-
+DFS
+```java
+//这里的实现为主函数处理每个岛屿的第一块陆地 方式
+//所以是主函数直接置count为1，剩余的交给dfs来做。
+import java.util.*;
+public class Main{
+    static int[][] dir = {{0,-1}, {1,0}, {0,1}, {-1, 0}};//四个方向
+    static int count = 0;
+    public static void dfs(boolean[][] visited, int x, int y, int[][] grid){
+        for(int i = 0; i < 4; i++){
+            int nextX = x + dir[i][0];
+            int nextY = y + dir[i][1];
+            if(nextX < 0 || nextY < 0 || nextY >= grid[0].length || nextX >= grid.length){
+                continue;
+            }
+            if(!visited[nextX][nextY] && grid[nextX][nextY] == 1){
+                count++;
+                visited[nextX][nextY] = true;
+                dfs(visited, nextX, nextY, grid);
+            }
+        }
+    }
+    public static void main(String[] args){
+        Scanner in = new Scanner(System.in);
+        int n = in.nextInt();
+        int m = in.nextInt();
+        int[][] grid = new int[n][m];
+        for(int i = 0; i < n; i++){
+            for(int j = 0; j < m; j++){
+                grid[i][j] = in.nextInt();
+            }
+        }
+        
+        int result = 0;
+        boolean[][] visited = new boolean[n][m];
+        for(int i = 0; i < n; i++){
+            for(int j = 0; j < m; j++){
+                if(!visited[i][j] && grid[i][j] == 1){
+                    visited[i][j] = true;
+                    count = 1;
+                    dfs(visited, i, j, grid);
+                    //dfs遍历完了一座岛屿，就比较count和result，保留最大的
+                    result = Math.max(result, count);                                         
+                }
+            }
+        }
+        System.out.println(result);
+    }
+}
+```
+BFS
+```java
+import java.util.*;
+public class Main{
+    static int[][] dir = {{0,-1}, {1,0}, {0,1}, {-1, 0}};//下右上左的顺序
+    static int count = 0;
+    public static void bfs(boolean[][] visited, int x, int y, int[][] grid){
+        Queue<pair> queue = new LinkedList<pair>();
+        queue.add(new pair(x,y));
+        count = 1; //该岛屿的第一块陆地被visit了
+        
+        //对这个岛屿的所有都入队，除非上下左右都没有未访问的陆地
+        while(!queue.isEmpty()){
+            int curX = queue.peek().x;
+            int curY = queue.poll().y;
+            //对每块陆地都进行上下左右的入队和计算（遍历），自然就是按广度优先了
+            for(int i = 0; i < 4; i++){
+                int nextX = curX + dir[i][0];
+                int nextY = curY + dir[i][1];
+                if(nextX < 0 || nextY < 0 || nextX >= grid.length || nextY >= grid[0].length){
+                    continue;
+                }
+                if(!visited[nextX][nextY] && grid[nextX][nextY] == 1){
+                    count++;
+                    queue.add(new pair(nextX, nextY));
+                    visited[nextX][nextY] = true;
+                }
+            }
+        }
+    }
+    
+    static class pair{
+        int x;
+        int y;
+        pair(int x, int y){
+            this.x = x;
+            this.y = y;
+        }
+    }
+    
+    public static void main(String[] args){
+        Scanner in = new Scanner(System.in);
+        int n = in.nextInt();
+        int m = in.nextInt();
+        int[][] grid = new int[n][m];
+        for(int i = 0; i < n; i++){
+            for(int j = 0; j < m; j++){
+                grid[i][j] = in.nextInt();
+            }
+        }
+        int result = 0;
+        boolean[][] visited = new boolean[n][m];
+        for(int i = 0; i < n; i++){
+            for(int j = 0; j < m; j++){
+                if(!visited[i][j] && grid[i][j] == 1){
+                    visited[i][j] = true;
+                    bfs(visited, i, j, grid);
+                    result = Math.max(result, count);
+                }
+            }
+        }
+        System.out.println(result);
+    }
+}
+```
 ### Python
 
 DFS