DFS的基本结构
网格结构比二叉树结构稍微复杂一点，它其实是一种简化版的图的结构。要写好网格上的DFS遍历，我们首先要理解二叉树上的DFS遍历方法，再类比写出网格结构上的DFS遍历。我们写的二叉树DFS遍历一般是：
public void traverse(TreeNode root) {
//判断 base case
if(root == null) {
return;
}
//访问两个相邻结点：左子节点、右子节点
traverse(root.left);
traverse(root.right);
}由此得出，二叉树的DFS有两个要素：【访问相邻结点】和【判断 base case】。
第一个要素是访问相邻结点。二叉树的相邻结点非常简单，只有左子结点和右子节点两个。二叉树本身就是一个递归定义的结构：一棵二叉树，它的左子树和右子树也是一棵二叉树。那么我们的DFS遍历只需要递归调用左子树和右子树即可。
第二个要素是判断base case。一般来说，二叉树遍历的base case是root == null。这样一个条件判断其实有两个含义：一方面，这表示 root 指向的子树为空，不需要再往下遍历了。另一方面，在root == null 的时候即时返回，可以让后面的 root.left 和 root.right 操作不会出现空指针异常。
对于网格上的DFS，我们完全可以参考二叉树的DFS，写出网格DFS的两个要素：
首先，网格结构中的格子 上下左右 四个相邻节点。对于格子 (r, c) 来说 (r 和 c 分别代表行坐标和列坐标)，四个相邻的格子分别是 (r-1, c)、(r+1, c)、(r, c-1)、(r, c+1)。
其次，网格DFS中的base case是什么？从二叉树的base case 对应过来，应该是网格中不需要继续遍历、grid[r][c] 会出现数组下标越界异常的格子，也就是那些超出网格范围的格子。
这一点稍微有些反直觉，坐标竟然可以临时超出网格范围？这种方法我称为【先污染后治理】 ———甭管当前是在哪个格子，先往四个方向走一步再说，如果发现走出了网格范围再赶快返回。这跟二叉树的遍历方法是一样的，先递归调用，发现 root == null 再返回。
这样，我们得到了网格DFS遍历的框架代码：
public 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);
}
public void inArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length && 0 <= c && c < grid[0].length;
}如何避免重复遍历
网格结构的DFS与二叉树的DFS最大的不同之处在于，遍历中可能遇到遍历过的结点。这是因为，网格结构本质上是一个图，我们可以把每个格子看成图中的结点，每个结点有向上下遍历时边。在图中遍历时，自然可能遇到重复遍历结点。
这时候，DFS可能会不停地”兜圈子“，永远停不下来。
要避免重复遍历，可以把已经遍历过的格子做一下标记。以岛屿问题为例，我们需要在所有值为1的陆地格子上做DFS遍历。每走过一个陆地格子，就把格子的值改为2，这样当我们遇到2的时候，就知道这是遍历过的格子 。就是说，每个格子可能取三个值：
- 0 —— 海洋格子
- 1 —— 陆地格子（未遍历过）
- 2 —— 陆地格子（已遍历过）
加入避免重复遍历的语句之后：
public 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);
}
//判断坐标是否在网格中
public 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必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被0（代表海洋）包围着。
找到给定的二维数组中最大的岛屿面积。如果没有岛屿，则返回面积为0。
这道题只需要对每个岛屿做DFS遍历，求出每个岛屿的面积就可以了。求岛屿面积的方法也很简单，代码如下：
public int maxAreaOfIsland(int[][] grid) {
int res = 0;
for(int r = 0; r < grid.length; r++) {
for(int c = 0; c < grid[0].length; r++) {
if(grid[r][c] == 1) {
int a = area(grid, r, c);
res = Math.max(res, a);
}
}
}
return res;
}
public int area(int[][] grid, int r, int c) {
if(!inArea(grid, r, c)) {
return 0;
}
if(grid[r][c] != 1) {
return 0;
}
grid[r][c] = 2;
return 1
+ area(grid, r-1, c)
+ area(grid, r+1, c)
+ area(grid, r, c-1)
+ area(grid, r, c+1);
}
public boolean inArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length
&& 0 <= c && c < grid[0].length;
}2、填海造陆问题
这道题是岛屿最大面积的升级版。现在我们有填海造陆的能力，可以把一个海洋格子变成陆地格子，进而让两块岛屿连成一块。那么填海造陆之后，最大可能构造出多大的岛屿呢？
大致思路：我们先计算出所有岛屿的面积，在所有的格子上标记出岛屿的面积。然后搜索哪个海洋格子相邻的两个岛屿面积最大。例如下图中红色方框内的海洋格子，上边、左边都与岛屿相邻，我们可以计算出它变成陆地以后可以连接成的岛屿面积为7+1+2=10
然后，这种做法可能遇到一个问题。如下图种红色方框内的海洋格子，它的上边、左边都与岛屿相邻，这时候连接成的岛屿面积难道是 7+1+7 ？！显然不是。这两个7来自同一个岛屿，所以填海造陆之后得到的岛屿面积应该只有 7+1=8
所以，我们要区分一个海洋格子相邻的两个7是不是来自同一个岛屿。所以，我们在方格中不能标记岛屿的面积，而应该标记岛屿的面积，如下图所示。这样我们就可以发现红色方框内的海洋格子，它的两个相邻的岛屿实际上是同一个。
可以看到，这道题实际上是对网格做了两边DFS：第一步遍历，计算面积并标记；第二遍DFS遍历，观察每个海洋相邻的陆地格子
class Solution {
public int largestIsland(int[][] grid) {
if (grid == null || grid.length == 0) return 1;
int result = 0, index = 2;
HashMap<Integer, Integer> areasMap = new HashMap();
for (int i = 0; i < grid.length; i++)
for (int j = 0; j < grid[0].length; j++)
if (grid[i][j] == 1) areasMap.put(index, calculateAreas(index++, grid, i, j)); // 只计算未编号的岛屿
if (areasMap.size() == 0) return 1; // 没有岛屿，全是海洋
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
if (grid[i][j] == 0) {
Set<Integer> islands = getIslands(grid, i, j);
if (islands.size() == 0) continue; // 周围没有岛屿
result = Math.max(result, islands.stream().map(item -> areasMap.get(item)).reduce(Integer::sum).orElse(0) + 1);
}
}
}
if (result == 0) return areasMap.get(2); // 全是岛屿，没有海洋
return result;
}
public int calculateAreas(int index, int[][] grid, int row, int column) {
if (!isLegal(grid, row, column) || grid[row][column] != 1) return 0;
grid[row][column] = index;
return calculateAreas(index, grid, row + 1, column) + calculateAreas(index, grid, row - 1, column) + calculateAreas(index, grid, row, column - 1) + calculateAreas(index, grid, row, column + 1) + 1;
}
public boolean isLegal(int[][] grid, int row, int column) {
return row >= 0 && row < grid.length && column >= 0 && column < grid[0].length;
}
public Set<Integer> getIslands(int[][] grid, int row, int column) {
Set<Integer> result = new HashSet<>();
if (isLegal(grid, row + 1, column) && grid[row + 1][column] != 0)
result.add(grid[row + 1][column]);
if (isLegal(grid, row - 1, column) && grid[row - 1][column] != 0)
result.add(grid[row - 1][column]);
if (isLegal(grid, row, column - 1) && grid[row][column - 1] != 0)
result.add(grid[row][column - 1]);
if (isLegal(grid, row, column + 1) && grid[row][column + 1] != 0)
result.add(grid[row][column + 1]);
return result;
}
}
3、岛屿的周长
网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
说实话，这道题用DFS来解并不是最优的方法。对于岛屿，直接用数学的方法求周长会更容易。不过这道题是一个很好理解DFS遍历过程的例题。
岛屿的周长是计算岛屿全部的边缘，而这些边缘就是我们在DFS遍历中，DFS函数返回的位置。观察题目示例，我们可以将岛屿的周长中的边分为两类，如下图所示。黄色的边是与网格边界相邻的周长，而蓝色的边是与海洋格子相邻的周长。
当我们的 dfs 函数因为坐标(r, c) 超出网格范围返回的时候，实际上就经过了一条黄色的边；而当函数因为当前格子是海洋格子返回的时候，实际上就经过了一条蓝色的边。这样，我们就把岛屿的周长跟DFS遍历联系起来了：
public int islandPerimeter(int[][] grid) {
for(int r = 0; r < grid.length; r++) {
for(int c = 0; c < grid[0].length; c++) {
if(grid[r][c] == 1) {
return dfs(grid, r, c);
}
}
}
return 0;
}
public int dfs(int[][] grid, int r, int c) {
if(!inArea(grid, r, c)) {
return 1;
}
if(grid[r][c] == 0) {
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);
}
public boolean inArea(int[][] grid, int r, int c) {
return 0 <= r && r < grid.length
&& 0 <= c && c < grid[0].length;
}
扫一扫
726
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
