原文链接：https://blog.csdn.net/qq_39355828/article/details/121108180 (opens new window)

Leetcode2021.11.2

105. 岛屿的最大面积 (opens new window)

难度中等585

给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0。

package offer;

public class offer105
{   int res=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)
                 //res是当前的连通区域内的岛屿数，然后与记录的最大值进行比较
                 res=Math.max(MaxArea(grid,i,j),res);
         }
     }
     return res;
    }
    //计算最大值
    public int MaxArea(int[][] grid, int i, int j)
    {   //如果遍历已经出去了整个二维数组，越界，应当返回
        if(!InArea(grid,i,j))
            return 0;
        //不等于1，两种情况，第一是当前不是岛屿，另一种是已经遍历过
        if(grid[i][j]!=1)
            return 0;
        //遍历过变成2，防止重复遍历
        grid[i][j]=2;
        //1+向四个方向进行的遍历
        return 1+MaxArea(grid,i-1,j)+MaxArea(grid,i+1,j)+MaxArea(grid,i,j+1)+MaxArea(grid,i,j-1);
    }
    //判定是否越界
    boolean InArea(int[][] grid, int i, int j)
    {
        if(i<0||j<0||i>=grid.length||j>=grid[0].length)
            return false;
        return true;
    }
}

剑指 Offer II 107. 矩阵中的距离 (opens new window)

难度中等1

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。

两个相邻元素间的距离为 1 。

示例 1：

class Solution {
   static int[][]dirs={{-1,0},{1,0},{0,-1},{0,1}};
    public int[][] updateMatrix(int[][] mat)
    {
        int m=mat.length,n=mat[0].length;
        int[][]dist=new int[m][n];
        boolean[][]seen=new boolean[m][n];
        Queue<int[]>queue=new LinkedList<int[]>();
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(mat[i][j]==0)
                {   //将所有0的位置添加进入队列
                    queue.add(new int[]{i,j});
                    //并将这些位置置为true
                    seen[i][j]=true;
                }
            }
        }
        //开始进行广度优先遍历
        while (!queue.isEmpty())
        {
            int[] cell=queue.poll();
            int i=cell[0],j=cell[1];
            for(int d=0;d<4;++d)
            {
                int ni=i+dirs[d][0];
                int nj=j+dirs[d][1];
                if(ni>=0&&ni<m&&nj>=0&&nj<n&&!seen[ni][nj])
                {
                    dist[ni][nj]=dist[i][j]+1;
                    queue.offer(new int[]{ni,nj});
                    seen[ni][nj]=true;
                }
            }
        }
        return dist;
    }}