岛屿问题(DFS)

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)_第1张图片

其次,网格DFS中的base case是什么?从二叉树的base case 对应过来,应该是网格中不需要继续遍历、grid[r][c] 会出现数组下标越界异常的格子,也就是那些超出网格范围的格子。

岛屿问题(DFS)_第2张图片

这一点稍微有些反直觉,坐标竟然可以临时超出网格范围?这种方法我称为【先污染后治理】 ———甭管当前是在哪个格子,先往四个方向走一步再说,如果发现走出了网格范围再赶快返回。这跟二叉树的遍历方法是一样的,先递归调用,发现 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、岛屿的最大面积

695. 岛屿的最大面积 - 力扣(LeetCode)

给定一个包含了一些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、填海造陆问题

827. 最大人工岛 - 力扣(LeetCode)

这道题是岛屿最大面积的升级版。现在我们有填海造陆的能力,可以把一个海洋格子变成陆地格子,进而让两块岛屿连成一块。那么填海造陆之后,最大可能构造出多大的岛屿呢?

大致思路:我们先计算出所有岛屿的面积,在所有的格子上标记出岛屿的面积。然后搜索哪个海洋格子相邻的两个岛屿面积最大。例如下图中红色方框内的海洋格子,上边、左边都与岛屿相邻,我们可以计算出它变成陆地以后可以连接成的岛屿面积为7+1+2=10岛屿问题(DFS)_第3张图片 

然后,这种做法可能遇到一个问题。如下图种红色方框内的海洋格子,它的上边、左边都与岛屿相邻,这时候连接成的岛屿面积难道是 7+1+7 ?!显然不是。这两个7来自同一个岛屿,所以填海造陆之后得到的岛屿面积应该只有 7+1=8岛屿问题(DFS)_第4张图片 

 所以,我们要区分一个海洋格子相邻的两个7是不是来自同一个岛屿。所以,我们在方格中不能标记岛屿的面积,而应该标记岛屿的面积,如下图所示。这样我们就可以发现红色方框内的海洋格子,它的两个相邻的岛屿实际上是同一个。岛屿问题(DFS)_第5张图片

可以看到,这道题实际上是对网格做了两边DFS:第一步遍历,计算面积并标记;第二遍DFS遍历,观察每个海洋相邻的陆地格子

class Solution {
    public int largestIsland(int[][] grid) {
        if (grid == null || grid.length == 0) return 1;
        int result = 0, index = 2;
        HashMap 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 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 getIslands(int[][] grid, int row, int column) {
        Set 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、岛屿的周长

463. 岛屿的周长 - 力扣(LeetCode)

网格中的格子 水平和垂直 方向相连(对角线方向不相连)。整个网格被水完全包围,但其中恰好有一个岛屿(或者说,一个或多个表示陆地的格子相连组成的岛屿)。

岛屿中没有“湖”(“湖” 指水域在岛屿内部且不和岛屿周围的水相连)。格子是边长为 1 的正方形。网格为长方形,且宽度和高度均不超过 100 。计算这个岛屿的周长。

说实话,这道题用DFS来解并不是最优的方法。对于岛屿,直接用数学的方法求周长会更容易。不过这道题是一个很好理解DFS遍历过程的例题。

岛屿的周长是计算岛屿全部的边缘,而这些边缘就是我们在DFS遍历中,DFS函数返回的位置。观察题目示例,我们可以将岛屿的周长中的边分为两类,如下图所示。黄色的边是与网格边界相邻的周长,而蓝色的边是与海洋格子相邻的周长。岛屿问题(DFS)_第6张图片

当我们的 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;
}

你可能感兴趣的:(深度优先,算法,图论)