LeetCode#695 Max Area of Island

最新推荐文章于 2025-12-10 10:56:12 发布

原创最新推荐文章于 2025-12-10 10:56:12 发布 · 257 阅读

0 ·

CC 4.0 BY-SA版权

本文详细解析了如何通过深度优先搜索(DFS)算法及其非递归实现来寻找二维网格中岛屿的最大面积。针对每个岛屿，使用DFS进行遍历并标记已访问区域，最终找出最大面积。

1、很明显，这是一个图的遍历。采用深度优先遍历的递归如下：每一个节点都完成向四周的扩散直至达到顶点

class Solution {
private:
    int dfs(vector<vector<int>>& grid, int i, int j){

        if(i < 0 || i >= m || j < 0 || j >= n || grid[i][j] != 1)
            return 0;

        grid[i][j] = 2;

        return 1+dfs(grid, i+1, j)+dfs(grid, i-1, j)+dfs(grid, i, j+1)+dfs(grid, i, j-1);
    }
public:
    int m;
    int n;
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        m = grid.size();
        n = grid[0].size();
        int maxSquare = 0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 1){
                    int count = dfs(grid, i, j);


                    if(maxSquare < count)
                        maxSquare = count;
                }
            }
        }

        return maxSquare;
    }
};

对于非递归，需要采用栈存储当前的起始点，当一条分支完成后返回此分支的起始点（出栈）另择分支。注意这是四个方向都有，四个方向都不存在时出栈

class Solution {
public:
    int m;
    int n;
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        m = grid.size();
        n = grid[0].size();
        int maxSquare = 0;
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 1){
                    int count = 1;
                    int stack[m*n][2] = { 0 };
                    int sp = 0;

                    stack[sp][0] = i;
                    stack[sp][1] = j;
                    grid[i][j] = 2;

                    while(sp >= 0){
                        //up
                        if(i > 0 && grid[i-1][j] == 1){
                            sp++;
                            stack[sp][0] = i-1;
                            stack[sp][1] = j;
                            grid[i-1][j] = 2;
                            count++;

                        }
                        //down
                        if(i < m-1 && grid[i+1][j] == 1){
                            sp++;
                            stack[sp][0] = i+1;
                            stack[sp][1] = j;
                            grid[i+1][j] = 2;
                            count++;
                        }
                        //left
                        if(j > 0 && grid[i][j-1] == 1){
                            sp++;
                            stack[sp][0] = i;
                            stack[sp][1] = j-1;
                            grid[i][j-1] = 2;
                            count++;
                        }
                        //right
                        if(j < n-1 && grid[i][j+1] == 1){
                            sp++;
                            stack[sp][0] = i;
                            stack[sp][1] = j+1;
                            grid[i][j+1] = 2;
                            count++;
                        }
                        i = stack[sp][0];
                        j = stack[sp][1];
                        sp--;
                    }

                    if(maxSquare < count)
                        maxSquare = count;
                }
            }
        }

        return maxSquare;
    }
};