leetcode-695. 岛屿的最大面积
深度优先搜索(dfs)
题目详情
给你一个大小为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}; //利用direction来控制方向搜索
int maxAreaOfIsland(vector<vector<int>>& grid)
{
//m为行 n为列 临时块 最大块
int m = grid.size(), n = m? grid[0].size() : 0,local_area, area = 0, x, y;
for (int i = 0;i < m; ++i)
{
for (int j =0;j < n; ++j)
{
if(grid[i][j]) //遍历到的是陆地
{
local_area = 1; //临时增加一块陆地
grid[i][j] = 0; //遍历过的块归零
stack<pair<int, int>> island; //用存pair数据的栈存陆地点
island.push({i, j}); //将这块陆地点入栈
while (!island.empty())
{
auto [r, c] = island.top(); //[r,c]数对暂存栈顶元素
island.pop(); //栈顶元素无用了出栈
for (int k = 0; k < 4; ++k)
{
x = r + direction[k], y = c + direction[k+1]; //开始上下左右移动搜寻
//x = r + -1 , y = c + 0 ----行-1,即向上
//x = r + 0 , y = c + 1 ----列+1,即向右
//x = r + 1 , y = c + 0 ----行+1,即向下
//x = r + 0 , y = c + -1 ----列-1,即向左
//确保不越界 且 该块为陆地
if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1)
{
grid[x][y] = 0; //遍历过的块归零
++local_area; //此次while扩容的总面积+1
island.push({x, y}); //将新块入栈
}
}
}
area = max(area, local_area); //每一次while就比较是否更新一次最大面积
}
}
}
return area;
}
};
第二种方法(递归)(辅函数先判定是否越界，只有在合法的情况下才进行下一步搜索（即判断放在调用递归函数前))
class Solution
{
public:
vector<int> direction{-1, 0, 1, 0, -1}; //利用direction来控制方向搜索
//辅函数,用来递归移动搜索
int dfs(vector<vector<int>>& grid, int r, int c)
{
if (grid[r][c] == 0) //海水返回0,同时这里也是递归出口
return 0;
grid[r][c] = 0; //搜索过的陆地归零为海水
int x, y, area = 1; //area总面积初始化为1
for (int i = 0; i < 4; ++i)
{
//上下左右遍历
x = r + direction[i], y = c + direction[i+1];
if (x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size()) //不越界
{
area += dfs(grid, x, y); //递归继续寻找,加上相应的面积
}
}
return area;
}
int maxAreaOfIsland(vector<vector<int>>& grid)
{
if (grid.empty() || grid[0].empty()) //空的直接返回0
return 0;
int max_area = 0; //存最大面积
//遍历寻找陆地并更新max_area
for (int i = 0; i < grid.size(); ++i)
{
for (int j = 0;j < grid[0].size(); ++j)
{
if(grid[i][j] == 1)
{
max_area = max(max_area, dfs(grid, i, j));
}
}
}
return max_area;
}
};
另一种递归(不管三七二十一先进行下一步搜索，待下一步搜索开始时再判断是否合法（即判断放在辅函数第一行）)
//上一种递归是判断好下一块不越界再dfs下一块
//这一种递归是dfs下一块之后再在下一块判断是否越界
class Solution
{
public:
//辅函数,用来递归四面八方搜索
int dfs(vector<vector<int>>& grid, int r, int c)
{
//越界或为海水
if (r < 0 || r >= grid.size() || c < 0 || c >= grid[0].size() || grid[r][c] == 0)
return 0;
grid[r][c] = 0;
return 1 + dfs(grid, r + 1, c) + dfs(grid, r - 1, c) + dfs(grid, r, c + 1) + dfs(grid, r, c-1);
}
int maxAreaOfIsland(vector<vector<int>>& grid)
{
if(grid.empty() || grid[0].empty())
return 0;
int max_area = 0;
for (int i = 0; i < grid.size(); ++i)
{
for (int j = 0; j < grid[0].size(); ++j)
{
max_area = max(max_area, dfs(grid, i, j));
}
}
return max_area;
}
};
涉及知识点:
1.深度优先搜索(dfs)
深度优先搜索（depth-first seach，DFS）在搜索到一个新的节点时，立即对该新节点进行遍历；因此遍历需要用先入后出的栈来实现，也可以通过与栈等价的递归来实现。对于树结构而言，由于总是对新节点调用遍历，因此看起来是向着“深”的方向前进。
