深度优先搜索
算法解释
深度优先搜索(depth-first search,DFS)在搜索到一个新的未曾访问过的节点之后,立刻对于当前的节点进行遍历;因此可以使用递归来实现,相应的很自然的也就可以使用先进后出的栈来实现。对于数或者图而言,由于总是遍历新的节点,所以总是向着更深处前进。
一般来说,深度优先搜索类型的题可以分为主函数和辅函数,主函数用于遍历所有的位置,也就是说主函数提供一个进入遍历环节的入口,判断是否可以进行遍历,如果可以就进行深度优先遍历。辅函数则负责深度优先搜索的递归使用,要注意递归的时候一定要设置好基线条件。
刷题的时候,一般建议采用递归写法,当然在最终工程上的时候还是建议采用栈的方式,因为这样的化运行速度会更快并且不会出现递归栈满的情况。
具体的题目学习
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。
非递归写法
class Solution {
public:
vector<int> direction{-1,0,1,0,-1};
int maxAreaOfIsland(vector<vector<int>>& grid) {
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>> s;
s.push({i,j});
while(!s.empty())
{
auto [p,q] = s.top();
s.pop();
for(int k = 0;k < 4; k++)
{
x = p+direction[k];
y = q+direction[k+1];
if(x>=0&&x<m&&y>=0&&y<n&&grid[x][y])
{
s.push({x,y});
grid[x][y] = 0;
local_area++;
}
}
}
area = max(area,local_area);
}
}
}
return area;
}
};
注:
(1)这里使用了第一个小技巧:那就是对于二维数组上的四个方向的遍历,我们采用了一个{-1,0,1,0,-1}来进行存储,简化了表示的步骤。
(2)一定要注意边界条件的表示,不能超过数组的边界
(3)那就是对于本题的状态记录或者说是记录化,没有按照一般的遍历时额外设置visit数组来存储遍历情况,而是使得遍历过的1变成了0,在原来基础上表示出已经遍历的信息是刷题时优先要考虑的,会简化空间复杂度。
递归的两种写法
一般是要分开设置为主函数和辅助函数,提供深度优先遍历的接口和具体实现的细节
第一种
class Solution {
public:
//存储四个遍历方向的数组
vector<int> direction{-1,0,1,0,-1};
//主函数
int maxAreaOfIsland(vector<vector<int>>& grid)
{
int m = grid.size(),n = m?grid[0].size():0,area = 0;
if(!m||!n) return 0;
for(int i = 0;i < m;++i)
{
for(int j = 0;j < n;++j)
{
if(grid[i][j])
{
area = max(area,helper(grid,i,j));
}
}
}
return area;
}
//辅助函数
int helper(vector<vector<int>>&grid,int i,int j)
{
//优先设置边界条件,在递归中也就是所谓的基线条件
if(i<0||i>=grid.size()||j<0||j>=grid[0].size()||grid[i][j]==0) return 0;
int sum = 1;
//将原来的单元置零以表示已经遍历过了
grid[i][j] = 0;
for(int k = 0;k<4;++k)
{
sum += helper(grid,i+direction[k],j+direction[k+1]);
}
return sum;
}
};
这种递归是先进行下一步的搜索,但是在下一次的搜索的开始会进行检查是否满足遍历的条件。
第二种递归
主函数不改变,主要是对于辅助函数的判断条件进行微调
int helper(vector<vector<int>>&grid,int i,int j)
{
//优先设置边界条件,在递归中也就是所谓的基线条件
int sum = 1,x,y;
//将原来的单元置零以表示已经遍历过了
grid[i][j] = 0;
for(int k = 0;k<4;++k)
{
x = i+direction[k],y = j+direction[k+1];
//对于是否进入下一次递归而进行判断
if(x>=0&&x<grid.size()&&y>=0&&y<grid[0].size()&&grid[x][y])
{
sum += helper(grid,x,y);
}
}
return sum;
}