@@ -189,6 +189,135 @@ public:
189189```
190190
191191# 其它语言版本
192+ ## Java
193+ ### DFS
194+ ```java
195+ // DFS
196+ class Solution {
197+ int[][] dir = {
198+ {0, 1}, //right
199+ {1, 0}, //down
200+ {0, -1}, //left
201+ {-1, 0} //up
202+ };
203+ boolean visited[][];
204+ int count;
205+ public int maxAreaOfIsland(int[][] grid) {
206+ int res = 0;
207+ visited = new boolean[grid.length][grid[0].length];
208+ for(int i = 0; i < grid.length; i++){
209+ for(int j = 0; j < grid[0].length; j++){
210+ if(visited[i][j] == false && grid[i][j] == 1){
211+ count = 0;
212+ dfs(grid, i, j);
213+ res = Math.max(res, count);
214+ }
215+ }
216+ }
217+ return res;
218+ }
219+ private void dfs(int[][] grid, int x, int y){
220+ if(visited[x][y] == true || grid[x][y] == 0)
221+ return;
222+
223+ visited[x][y] = true;
224+ count++;
225+
226+ for(int i = 0; i < 4; i++){
227+ int nextX = x + dir[i][0];
228+ int nextY = y + dir[i][1];
229+
230+ if(nextX < 0 || nextY < 0 || nextX >= grid.length || nextY >= grid[0].length)
231+ continue;
232+ dfs(grid, nextX, nextY);
233+ }
234+ }
235+ }
236+
237+
238+ ```
239+ ### BFS
240+ ``` java
241+ // BFS
242+ class Solution {
243+ int [][] dir = {
244+ {0 , 1 }, {1 , 0 }, {0 , - 1 }, {- 1 , 0 }
245+ };
246+ 247+ int count;
248+ boolean visited[][];
249+ 250+ public int maxAreaOfIsland (int [][] grid ) {
251+ int res = 0 ;
252+ visited = new boolean [grid. length][grid[0 ].length];
253+ 254+ for (int i = 0 ; i < grid. length; i++ ){
255+ for (int j = 0 ; j < grid[0 ]. length; j++ ){
256+ if (visited[i][j] == false && grid[i][j] == 1 ){
257+ count = 0 ;
258+ bfs(grid, i, j);
259+ res = Math . max(res, count);
260+ }
261+ }
262+ }
263+ return res;
264+ }
265+ private void bfs (int [][] grid , int x , int y ){
266+ Queue<Integer > que = new LinkedList<> ();
267+ que. offer(x);
268+ que. offer(y);
269+ visited[x][y] = true ;
270+ count++ ;
271+ 272+ while (! que. isEmpty()){
273+ int currX = que. poll();
274+ int currY = que. poll();
275+ 276+ for (int i = 0 ; i < 4 ; i++ ){
277+ int nextX = currX + dir[i][0 ];
278+ int nextY = currY + dir[i][1 ];
279+ 280+ if (nextX < 0 || nextY < 0 || nextX >= grid. length || nextY >= grid[0 ]. length)
281+ continue ;
282+ if (visited[nextX][nextY] == false && grid[nextX][nextY] == 1 ){
283+ que. offer(nextX);
284+ que. offer(nextY);
285+ visited[nextX][nextY] = true ;
286+ count++ ;
287+ }
288+ }
289+ }
290+ }
291+ }
292+ ```
293+ ### DFS 優化(遇到島嶼後,就把他淹沒)
294+ ``` java
295+ // 这里使用深度优先搜索 DFS 来完成本道题目。我们使用 DFS 计算一个岛屿的面积,同时维护计算过的最大的岛屿面积。同时,为了避免对岛屿重复计算,我们在 DFS 的时候对岛屿进行 "淹没" 操作,即将岛屿所占的地方置为 0。
296+ public int maxAreaOfIsland(int [][] grid) {
297+ int res = 0 ;
298+ for (int i = 0 ;i < grid. length;i++ ){
299+ for (int j = 0 ;j < grid[0 ]. length;j++ ){
300+ // 每遇到一个岛屿就计算这个岛屿的面积同时"淹没"这个岛屿
301+ if (grid[i][j] == 1 ){
302+ // 每次计算一个岛屿的面积都要与res比较,维护最大的岛屿面积作为最后的答案
303+ res = Math . max(res,dfs(grid,i,j));
304+ }
305+ }
306+ }
307+ return res;
308+ }
309+ public int dfs(int [][] grid,int i,int j){
310+ // 搜索边界:i,j超过grid的范围或者当前元素为0,即当前所在的地方已经是海洋
311+ if (i < 0 || i >= grid. length || j < 0 || j >= grid[0 ]. length || grid[i][j] == 0 ) return 0 ;
312+ // 淹没土地,防止后续被重复计算
313+ grid[i][j] = 0 ;
314+ // 递归的思路:要求当前土地(i,j)所在的岛屿的面积,则等于1加上下左右相邻的土地的总面积
315+ return 1 + dfs(grid,i - 1 ,j) +
316+ dfs(grid,i + 1 ,j) +
317+ dfs(grid,i,j + 1 ) +
318+ dfs(grid,i,j - 1 );
319+ }
320+ ```
192321
193322## Python
194323### BFS
@@ -261,39 +390,6 @@ class Solution:
261390 if 0 <= new_x < len (grid) and 0 <= new_y < len (grid[0 ]):
262391 self .dfs(grid, visited, new_x, new_y)
263392```
264- 265- 266- 267- ## Java
268- 269- 这里使用深度优先搜索 DFS 来完成本道题目。我们使用 DFS 计算一个岛屿的面积,同时维护计算过的最大的岛屿面积。同时,为了避免对岛屿重复计算,我们在 DFS 的时候对岛屿进行 "淹没" 操作,即将岛屿所占的地方置为 0。
270- 271- ``` java
272- public int maxAreaOfIsland(int [][] grid) {
273- int res = 0 ;
274- for (int i = 0 ;i < grid. length;i++ ){
275- for (int j = 0 ;j < grid[0 ]. length;j++ ){
276- // 每遇到一个岛屿就计算这个岛屿的面积同时"淹没"这个岛屿
277- if (grid[i][j] == 1 ){
278- // 每次计算一个岛屿的面积都要与res比较,维护最大的岛屿面积作为最后的答案
279- res = Math . max(res,dfs(grid,i,j));
280- }
281- }
282- }
283- return res;
284- }
285- public int dfs(int [][] grid,int i,int j){
286- // 搜索边界:i,j超过grid的范围或者当前元素为0,即当前所在的地方已经是海洋
287- if (i < 0 || i >= grid. length || j < 0 || j >= grid[0 ]. length || grid[i][j] == 0 ) return 0 ;
288- // 淹没土地,防止后续被重复计算
289- grid[i][j] = 0 ;
290- // 递归的思路:要求当前土地(i,j)所在的岛屿的面积,则等于1加上下左右相邻的土地的总面积
291- return 1 + dfs(grid,i - 1 ,j) +
292- dfs(grid,i + 1 ,j) +
293- dfs(grid,i,j + 1 ) +
294- dfs(grid,i,j - 1 );
295- }
296- ```
297393<p align="center">
298394<a href="https://programmercarl.com/other/kstar.html " target="_ blank">
299395 <img src =" ../pics/网站星球宣传海报.jpg " width =" 1000 " />
0 commit comments