剑指 Offer II 105. 岛屿的最大面积（695. 岛屿的最大面积）

题目：

 

 

 

思路：

【1】深度优先搜索

【2】广度优先搜索

代码展示：

广度优先搜索：

//时间7 ms击败6.66%
//内存41.3 MB击败88.39%
//时间复杂度：O(m×n)。其中 m 是给定网格中的行数，n 是列数。我们访问每个网格最多一次。
//空间复杂度：O(m×n)，队列中最多会存放所有的土地，土地的数量最多为 m×n 块，因此使用的空间为 O(m×n)。
class Solution {
    public int maxAreaOfIsland(int[][] grid) {
        int ans = 0;
        for (int i = 0; i != grid.length; ++i) {
            for (int j = 0; j != grid[0].length; ++j) {
                int cur = 0;
                Queue<Integer> queuei = new LinkedList<Integer>();
                Queue<Integer> queuej = new LinkedList<Integer>();
                queuei.offer(i);
                queuej.offer(j);
                while (!queuei.isEmpty()) {
                    int cur_i = queuei.poll(), cur_j = queuej.poll();
                    if (cur_i < 0 || cur_j < 0 || cur_i == grid.length || cur_j == grid[0].length || grid[cur_i][cur_j] != 1) {
                        continue;
                    }
                    ++cur;
                    //这里将小岛变海域，防止二次遍历
                    grid[cur_i][cur_j] = 0;
                    int[] di = {0, 0, 1, -1};
                    int[] dj = {1, -1, 0, 0};
                    for (int index = 0; index != 4; ++index) {
                        int next_i = cur_i + di[index], next_j = cur_j + dj[index];
                        queuei.offer(next_i);
                        queuej.offer(next_j);
                    }
                }
                ans = Math.max(ans, cur);
            }
        }
        return ans;
    }
}

 

深度优先搜索：

//时间1 ms击败100%
//内存41.4 MB击败68.78%
//时间复杂度：O(m×n)。其中 m 是给定网格中的行数，n 是列数。我们访问每个网格最多一次。
//空间复杂度：O(m×n)，递归的深度最大可能是整个网格的大小，因此最大可能使用 O(m×n) 的栈空间。
class Solution {
    int maxArea = 0, curArea = 0;
    public int maxAreaOfIsland(int[][] grid) {
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    curArea = 0;
                    infect(i, j, grid);
                    maxArea = Math.max(maxArea, curArea);
                }
            }
        }
        return maxArea;
    }
    public void infect(int x, int y, int[][] grid){
        //限制条件（首先是上下左右边界，其次是小岛土地判断）
        if(x < 0 || y < 0 || x >= grid.length || y >= grid[0].length || grid[x][y] == 0){
            return;
        }
        if(grid[x][y] == 1){
            curArea++;
            //这里是将岛屿遍历完后变为海域，防止二次遍历
            grid[x][y] = 0;
        }
        infect(x - 1, y, grid);
        infect(x + 1, y, grid);
        infect(x, y - 1, grid);
        infect(x, y + 1, grid);

    }
}