【LeetCode】695. 岛屿的最大面积

题目描述
给定一个包含了一些 0 和 1 的非空二维数组 grid 。

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

找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

示例 1:

[[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。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。

示例 2:

[[0,0,0,0,0,0,0,0]]
对于上面这个给定的矩阵, 返回 0。

题解：
(1) GTA 2021-03-10 打卡

(2) LeetCode 2021-03-10 题695提交记录

(3) DFS:
从数组(0,0)位置开始遍历，当遇到值为1的时候，进入深度搜索的逻辑。其中传参cnt表示1的个数，res用来保存各个岛屿的个数的最大值。
深度搜索：每次遇到1的时候，用于计数的cnt自增1，然后把当前的1设置为-1（表示访问过了），向上下左右4个方向搜索。当（i，j）越界的时候return或者当前的值为0或者-1也return。res用来更新最大值。

class Solution {
public:
    vector<vector<int>> dirs{{1,0}, {-1,0}, {0,1}, {0,-1}};
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int row = grid.size(); 
        int col = grid[0].size();
        int res = 0;
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j < col; j++)
            {
                if(grid[i][j] != 1 )
                    continue;
                int cnt = 0;
                dfs(grid, i, j, cnt, res);
            }
        }
        return res;
    }

    void dfs(vector<vector<int>>& grid, int i, int j, int& cnt, int& res)
    {
        int row = grid.size(); 
        int col = grid[0].size();
        if (i < 0 or i >= row or j < 0 or j >= col or grid[i][j] <= 0) 
            return;
        
        grid[i][j] = -1;
        cnt++;
        res=max(res, cnt);
        for (auto dir : dirs) {
            dfs(grid, i + dir[0], j + dir[1], cnt, res);
        }
    }
};

(4) BFS:
从数组（0,0）开始遍历，当遇到1的时候，将此元素放入队列中，初始化cnt=0.进入队列后，取出front（），并cnt++。然后把这个头元素四周的元素都加如到队列中（如果在范围内且为1，并且没有访问过）。这边访问过的1也会设置为-1。res也是取cnt的最大值。

class Solution {
public:
    vector<vector<int>> dirs{{1,0}, {-1,0}, {0,1}, {0,-1}};
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        int res = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] != 1) continue;
                int cnt = 0;
                queue<pair<int, int>> q;
                q.push({i,j});
                grid[i][j] = -1;
                while (!q.empty()) {
                    auto t = q.front(); q.pop();
                    cnt++;
                    res = max(res, cnt);
                    for (auto dir : dirs) {
                        int x = t.first + dir[0];
                        int y = t.second + dir[1];
                        if (x < 0 or x >= m or y < 0 or y >= n or grid[x][y] <= 0) continue;
                        q.push({x, y});
                        grid[x][y] = -1;
                    }
                }
            }
        }
        return res;
    }
};