695岛屿的最大面积

岛屿的最大面积

问题描述

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

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

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

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

DFS

const int dx[4] = {1,-1,0,0};
const int dy[4] = {0,0,1,-1};

int dfs(vector<vector<int>>& grid,int cur_x,int cur_y){
    if(cur_x<0||cur_x==grid.size()||cur_y<0||cur_y==grid[0].size()||gird[cur_x][cur_y]!=1){
        return 0;
    }
    grid[cur_x][cur_y] = 0;
    int ans = 1;
    for(int index = 0;index!=4;++index){
        int next_x = cur_x + dx[index],next_y = cur_y + dy[index];
        ans += dfs(grid,next_x,next);
    }
    return ans;
}

int maxAreaOfIsland(vector<vector<int>>& grid){
    int ans = 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));
        }
    }
    return ans;
}

复杂度

时间复杂度为O(m*n)

空间复杂度为O(m x n)，递归的深度最大可能是整个网格的大小，因此最大可能使用O(m x n)栈空间。

BFS

const int dx[4] = {0,0,1,-1};
const int dy[4] = {1,-1,0,0};

int maxAreaOfIsland(vector<vector<int>>& grid){
    int ans = 0;
    for(int i = 0;i<grid.size();++i){
        for(int j = 0;j<grid[0].size();++j){
            int cur = 0;
            queue<pair<int,int>> que;
            que.emplace(i,j);
            while(!que.empty()){
                int cur_x = que.front().first,cur_y = que.front().second;
                que.pop();
                if(cur_x<0||cur_x==grid.size()||cur_y<0||cur_y==grid[0].size()||grid[cur_x][cur_y]!=1){
                    continue;
                }
                ++cur;
                grid[cur_x][cur_y] = 0;
                for(int index = 0;index<4;++index){
                    int next_x = cur_x+dx[index],next_y = cur_y+dy[index];
                    que.emplace(next_x,next_y);
                }
            }
            ans = max(ans,cur);
        }
    }
    return ans;
}

复杂度

时间复杂度O(n x m)

空间复杂度为O(n x m)