深度优先搜索 | 695. 岛屿的最大面积

一、题目

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

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

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

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

示例 1：

输入：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
解释：答案不应该是 11 ，因为岛屿只能包含水平或垂直这四个方向上的 1 。
示例 2：

输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

二、题解

这道题是一道典型的搜索题，这里的一个岛屿也等价于一个环，所以我们使用深度优先搜索。
深度优先搜索的实现一般需要一个主函数和一个辅助函数，主函数用于遍历所有位置，判断并作为搜索的起点；辅助函数则用于一次的深度优先搜索。其中，深度优先搜索可以用递归或栈来实现，递归实现相对容易，可以用于刷题，栈的话工程里面比较多，可以防止递归栈满的情况。
另外，一旦使用递归的话就要考虑边界条件以及在边界条件下应该进行什么操作。有两种处理递归边界的方法：

• 先判断边界，再递归
• 先递归，再判断边界
  这两种方法对应的是辅助函数的两种写法,如下。

注意：在利用递归操作时这里搜索过的位置为了防止再次被搜索，对应的位置要标记为访问过。

三、代码

• 先判断边界，再递归

class Solution {
public:
    vector<int> direction{-1,0,1,0,-1};
    int maxAreaOfIsland(vector<vector<int>>& grid) {
     if(grid.empty()||grid[0].empty()) return 0;
     int res = 0;
     for(int i = 0;i<grid.size();i++){
         for(int j = 0;j<grid[0].size();j++){
             if(grid[i][j]== 1){
                res = max(res,dfs(grid,i,j));
             }

         }
     }
     return res;
    }

    int dfs(vector<vector<int>>& grid,int i,int j){
        if(grid[i][j]==0) return 0;
        grid[i][j] = 0;
        int r,c,count = 1;
        for(int k=0;k<4;k++){
           r = i +  direction[k];
           c =  j+direction[k+1];
           if(r < grid.size() && c < grid[0].size() && r >=0 && c>=0 && grid[r][c]!=0){
               count += dfs(grid,r,c);
           }
        }
        return count;
    }

};

• 先递归，再判断边界

class Solution {
public:
    vector<int> direction{-1,0,1,0,-1};
    int maxAreaOfIsland(vector<vector<int>>& grid) {
     if(grid.empty()||grid[0].empty()) return 0;
     int res = 0;
     for(int i = 0;i<grid.size();i++){
         for(int j = 0;j<grid[0].size();j++){
                res = max(res,dfs(grid,i,j));
         }
     }
     return res;
    }

    int dfs(vector<vector<int>>& grid,int i,int j){
        if(i < grid.size() && j < grid[0].size() && i >=0 && j>=0 && grid[i][j]!=0){
            grid[i][j] = 0;
            return 1+dfs(grid,i-1,j)+dfs(grid,i,j-1)+dfs(grid,i+1,j)+dfs(grid,i,j+1);
        }
        else return 0;
        
    }

};