本文章参考力扣nettee的文章和本人的部分见解,主要用于个人学习
作者：nettee
来源：力扣（LeetCode）
dfs ,也就是深度优先搜索,是一种常用于求解遍历和搜索问题的算法
可以将它理解为一条路走到黑的方法,从起点开始,先沿一条路走下去,直到走到尽头,再走另一条路
我们常用递归和栈来实现,像比如对树形结构的遍历,只要对两个子节点都进行和父节点相同的方法递归遍历就行,也常用于迷宫路径查找和图的连通性判断问题,对于以下的系列岛屿问题,就可以使用这种方法求解
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1：
输入：grid = [
['1','1','1','1','0'],
['1','1','0','1','0'],
['1','1','0','0','0'],
['0','0','0','0','0']
]
输出：1示例 2：
输入：grid = [
['1','1','0','0','0'],
['1','1','0','0','0'],
['0','0','1','0','0'],
['0','0','0','1','1']
]
输出：3对于这样的网格状问题,将0看成水,将1看成岛,进而可以出现类似的问题,比如求岛屿面积,周长等等
使用dfs可以对这些问题一并解决
网格结构要比二叉树结构稍微复杂一些，它其实是一种简化版的图结构。要写好网格上的 DFS 遍历，我们首先要理解二叉树上的 DFS 遍历方法，再类比写出网格结构上的 DFS 遍历。我们写的二叉树 DFS 遍历一般是这样的：
java
void traverse(TreeNode root) {
// 判断 base case
if (root == null) {
return;
}
// 访问两个相邻结点：左子结点、右子结点
traverse(root.left);
traverse(root.right);
}二叉树的dfs算法就是简单的对节点(判断base case)进行非空判断,然后对左右子节点进行递归调用方法(访问两个相邻节点)
但是这里的判断base case我们不能简单地将他看成对根节点进行非空判断,另一方面,它也是在判断当前节点是不是叶子节点,如果是叶子节点,他是没有子节点的,因此不能对null调用方法.
那么网格结构也可以类似二叉树处理,二叉树是看成每个节点都有两个子节点,那么网格结构中可以看成每个节点都有四个子节点
网格 DFS 中的 base case 应该怎么做呢?
首先网格是不会有根节点的,因此现在我们只要去找网格的叶子节点,
根据作者所说,将网格边缘的节点看成叶子节点,因为这些节点的子节点会出现为空的情况,它们不会拥有完整的四个子节点
这里引用原作者的一段话,很有道理
这一点稍微有些反直觉，坐标竟然可以临时超出网格的范围？这种方法我称为「先污染后治理」------ 甭管当前是在哪个格子，先往四个方向走一步再说，如果发现走出了网格范围再赶紧返回。这跟二叉树的遍历方法是一样的，先递归调用，发现 root == null 再返回。
那么现在就可以类比二叉树的处理方法处理网格:
java
void dfs(int[][] grid, int r, int c) {
// 判断 base case
// 如果坐标 (r, c) 超出了网格范围，直接返回
if (!inArea(grid, r, c)) {
return;
}
// 访问上、下、左、右四个相邻结点
dfs(grid, r - 1, c);
dfs(grid, r + 1, c);
dfs(grid, r, c - 1);
dfs(grid, r, c + 1);
}
// 判断坐标 (r, c) 是否在网格中
boolean inArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length
&& 0 <= c && c < grid[0].length;
}但是二叉树和网格是有区别的:二叉树有方向,而网格没有,所以会出现有节点被重复遍历的情况,因此,需要我们将每一个遍历过的岛屿节点设为2,每次遍历只遍历1的节点
将给遍历过的岛屿赋值代码添加到源代码中:
java
void dfs(int[][] grid, int r, int c) {
// 判断 base case
if (!inArea(grid, r, c)) {
return;
}
// 如果这个格子不是岛屿，直接返回
if (grid[r][c] != 1) {
return;
}
grid[r][c] = 2; // 将格子标记为「已遍历过」
// 访问上、下、左、右四个相邻结点
dfs(grid, r - 1, c);
dfs(grid, r + 1, c);
dfs(grid, r, c - 1);
dfs(grid, r, c + 1);
}
// 判断坐标 (r, c) 是否在网格中
boolean inArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length
&& 0 <= c && c < grid[0].length;
}综上,我们遍历到了每一个未被遍历到的岛屿节点,那么想求岛屿数量,面积,周长的问题也就能迎刃而解了,当然,周长问题可能困难些.
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1：
输入：grid = [
['1','1','1','1','0'],
['1','1','0','1','0'],
['1','1','0','0','0'],
['0','0','0','0','0']
]
输出：1示例 2：
输入：grid = [
['1','1','0','0','0'],
['1','1','0','0','0'],
['0','0','1','0','0'],
['0','0','0','1','1']
]
输出：3有了上面的基础,我们就可以轻松做出这道题
java
class Solution {
public int numIslands(char[][] grid) {
int count = 0;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == '1') {
dfs(grid, i, j);
count++;
}
}
}
return count;
}
private void dfs(char[][] grid, int r, int c) {
if (!inArea(grid, r, c)) {
return;
}
if (grid[r][c] != '1') {
return;
}
grid[r][c] = 2;
dfs(grid, r - 1, c);
dfs(grid, r + 1, c);
dfs(grid, r, c - 1);
dfs(grid, r, c + 1);
}
private boolean inArea(char[][] grid, int r, int c) {
return 0 <= r && r < grid.length && 0 <= c && c < grid[0].length;
}
}这里就像一种蔓延效果,一旦找到1,就对这个数的四个子节点进行dfs操作,如果这个子节点在范围内,并且也是1,那么也进行同样的操作,以此类推,这样我们就将这个节点相邻的所有1的节点给改成了2,并且count++,这就是一个岛屿,最后将count返回就行
给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。
网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有"湖"（"湖" 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
示例 1：
输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边示例 2：
输入：grid = [[1]]
输出：4示例 3：
输入：grid = [[1,0]]
输出：4这道题也是求岛屿相关的问题,所以我们还是使用dfs方法求解
java
class Solution {
public int islandPerimeter(int[][] grid) {
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 1) {
return dfs(grid, i, j);
}
}
}
return 0;
}
private int dfs(int[][] grid, int r, int c) {
//如果子节点超出范围,周长加1
if (!isArea(grid, r, c)) {
return 1;
}
//如果子节点是水,周长加1
if (grid[r][c] == 0) {
return 1;
}
//如果子节点是已经遍历过的岛屿,周长不变
if (grid[r][c] == 2) {
return 0;
}
grid[r][c] = 2;
return dfs(grid, r - 1, c)
+ dfs(grid, r + 1, c)
+ dfs(grid, r, c + 1)
+ dfs(grid, r, c - 1);
}
private boolean isArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length && 0 <= c && c < grid[0].length;
}
}首先基础框架还是一样,就是计算周长这一块,我们发现
周长由两部分组成:与网格边界相连的部分,与水相连的部分
因此,我们对一个节点的四个子节点进行dfs时,有以下几个情况
如果这个子节点超出边界,说明当前的父节点有一边靠近边界,周长加1
如果这个子节点是水,那么周长也是加1
如果这个字节点是未被遍历过的岛屿,那么对这个子节点的子节点也进行dfs,以此类推,并将其变为2,表示已经遍历过了的节点,之后不需要再对它处理
如果这个子节点是已经被遍历过的岛屿,那么周长不变
最后返回周长就行
给你一个大小为 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这里还是使用dfs算法
java
class Solution {
public int maxAreaOfIsland(int[][] grid) {
int max = 0;
for (int r = 0; r < grid.length; r++) {
for (int c = 0; c < grid[0].length; c++) {
if (grid[r][c] == 1) {
max = Math.max(max, dfs(grid, r, c));
}
}
}
return max;
}
private int dfs(int[][] grid, int r, int c) {
if (!isArea(grid, r, c) || grid[r][c] == 0 || grid[r][c] == 2) {
return 0;
}
grid[r][c] = 2;
return 1 + dfs(grid, r - 1, c) + dfs(grid, r + 1, c) + dfs(grid, r, c - 1) + dfs(grid, r, c + 1);
}
private boolean isArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length && 0 <= c && c < grid[0].length;
}
}还是一样,对父节点和子节点进行dfs,每个节点有以下几个情况:
如果节点是0,说明是水,不需要加面积
如果节点超出边界,面积不变
如果节点是2,说明这个节点已经计算过了,面积不变
如果节点是1,面积加1,并且对该节点的所有四个子节点进行相同处理
这样给我们就获取到了每一个岛屿的面积,最后进行最大值比较就行