剑指 Offer II 105. 岛屿的最大面积代码注释-CSDN博客

本文链接：https://blog.csdn.net/l203018/article/details/130661427

文章介绍了如何使用深度优先搜索（DFS）和广度优先搜索（BFS）策略来解决给定二维数组中找到最大岛屿面积的问题。在网格中，1代表土地，0代表水，岛屿由相邻的1组成。两种算法均会遍历所有1并将访问过的设为0，最后返回遍历到的岛屿数量。DFS从每个1开始递归探索相邻的1，而BFS使用队列逐层探索。

摘要由CSDN通过智能技术生成

题目：

给定一个由 0 和 1 组成的非空二维数组 grid ，用来表示海洋岛屿地图。

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

找到给定的二维数组中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。
输入: grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
输出: 6
解释: 对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1

思想：

数组中每个位置为1的当一个顶点，把数组当成图，遍历所有顶点，遍历到的置为0，遍历完一个岛ans++，邻接的有上下左右四个方向。

深度优先

class Solution
{
    int dfs(vector<vector<int>>& grid, int cur_i, int cur_j) //数组，当前下标i，j
    {
        if (cur_i < 0 || cur_j < 0 || cur_i == grid.size() || cur_j == grid[0].size() || grid[cur_i][cur_j] != 1) //若下标不合法或已经被访问过（或当前位置是水面）
        {
            return 0;//直接返回0
        }
        grid[cur_i][cur_j] = 0;//访问了当前下标，置为0，以后不再访问
        int di[4] = {0, 0, 1, -1};//
        int dj[4] = {1, -1, 0, 0};//和上面一行组成一个位置相邻的四个方向
        int ans = 1;
        for (int index = 0; index != 4; ++index) //一个点有四个相邻的位置，循环四次找陆地
        {
            int next_i = cur_i + di[index], next_j = cur_j + dj[index];//分别走这四个位置
            ans += dfs(grid, next_i, next_j);//小岛个数+深度遍历得到的个数
        }
        return ans;//返回结果
    }
public:
    int maxAreaOfIsland(vector<vector<int>>& grid)
    {
        int ans = 0;//初始岛屿个数为0
        for (int i = 0; i != grid.size(); ++i) //把每一个下标都放进去深度优先遍历
        {
            for (int j = 0; j != grid[0].size(); ++j) 
            {
                ans = max(ans, dfs(grid, i, j));//取当前结果ans和深度优先得到的岛屿数中大的
            }
        }
        return ans;
    }
};

广度优先

class Solution
{
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
        int ans = 0;//初始岛屿为0
        for (int i = 0; i != grid.size(); ++i)
        {
            for (int j = 0; j != grid[0].size(); ++j) 
            {
                int cur = 0;
//创建队列
                queue<int> queuei;
                queue<int> queuej;
//把当前位置的下标放到队列中
                queuei.push(i);
                queuej.push(j);
//若队列不为空
                while (!queuei.empty()) 
                {
//获取队头的下标
                    int cur_i = queuei.front(), cur_j = queuej.front();
//队头出队
                    queuei.pop();
                    queuej.pop();
//下标位置不合法
                    if (cur_i < 0 || cur_j < 0 || cur_i == grid.size() || cur_j == grid[0].size() || grid[cur_i][cur_j] != 1) 
                    {
                        continue;//下一个位置
                    }
//下标位置合法
                    ++cur;
//grid置为0，以后不再访问该点
                    grid[cur_i][cur_j] = 0;
//上下左右方向
                    int di[4] = {0, 0, 1, -1};
                    int dj[4] = {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.push(next_i);
                        queuej.push(next_j);
                    }
                }
//结果取大的
                ans = max(ans, cur);
            }
        }
        return ans;
    }
};

代码来源：力扣官方题解
链接：https://leetcode.cn/problems/ZL6zAn/solutions/1412188/dao-yu-de-zui-da-mian-ji-by-leetcode-sol-c9ni/