【DFS】200. 岛屿数量 & 130. 被围绕的区域 & 463. 岛屿的周长 & 695. 岛屿的最大面积 & 733. 图像渲染

最新推荐文章于 2023-01-05 10:50:13 发布

饥渴的小苹果

最新推荐文章于 2023-01-05 10:50:13 发布

阅读量369

点赞数

分类专栏： LeetCode

原文链接：https://leetcode-cn.com/problems/number-of-islands/solution/dao-yu-shu-liang-by-leetcode/

版权

LeetCode 专栏收录该内容

69 篇文章 2 订阅

订阅专栏

200. 岛屿数量

题目

200. 岛屿数量

给你一个由 ‘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

解法

深度优先搜索

我们可以将二维网格看成一个无向图，竖直或水平相邻的1 之间有边相连。

为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为1，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的1 都会被重新标记为0。

最终岛屿的数量就是我们进行深度优先搜索的次数。
在这里插入图片描述

class Solution {

    int nr;
    int nc;

    void dfs(char[][] grid, int r, int c) {
        // 如果到达边界了或者访问到了已访问
        if (r < 0 || c < 0 || r >= nr || c >= nc || grid[r][c] == '0') {
            return;
        }
        // 标记为已访问
        grid[r][c] = '0';
        // 向四个方向搜索
        dfs(grid, r + 1, c);
        dfs(grid, r - 1, c);
        dfs(grid, r, c - 1);
        dfs(grid, r, c + 1);
    }

    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }
        nr = grid.length;
        nc = grid[0].length;
        int num_islands = 0;
        for (int r = 0; r < nr; r++) {
            for (int c = 0; c < nc; c++) {
                if (grid[r][c] == '1') {
                    num_islands++;
                    // 将周围的1标记为0
                    dfs(grid, r, c);
                }
            }
        }
        return num_islands;
    }
}

130. 被围绕的区域

题目

130. 被围绕的区域

给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ ，找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例 1：
在这里插入图片描述
输入：board = [[“X”,“X”,“X”,“X”],[“X”,“O”,“O”,“X”],[“X”,“X”,“O”,“X”],[“X”,“O”,“X”,“X”]]
输出：[[“X”,“X”,“X”,“X”],[“X”,“X”,“X”,“X”],[“X”,“X”,“X”,“X”],[“X”,“O”,“X”,“X”]]
解释：被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

示例 2：
输入：board = [[“X”]]
输出：[[“X”]]

解法

本题给定的矩阵中有三种元素：

字母 X；
被字母 X 包围的字母 O；
没有被字母 X 包围的字母 O。

本题要求将所有被字母 X 包围的字母 O都变为字母 X ，但很难判断哪些 O 是被包围的，哪些 O 不是被包围的。

注意到题目解释中提到：任何边界上的 O 都不会被填充为 X。我们可以想到，所有的不被包围的 O 都直接或间接与边界上的 O 相连。我们可以利用这个性质判断 O 是否在边界上，具体地说：

对于每一个边界上的 O，我们以它为起点，标记所有与它直接或间接相连的字母 O；
最后我们遍历这个矩阵，对于每一个字母：
- 如果该字母被标记过，则该字母为没有被字母 X 包围的字母 O，我们将其还原为字母 O；
- 如果该字母没有被标记过，则该字母为被字母 X 包围的字母 O，我们将其修改为字母 X。

深度优先搜索

我们可以使用深度优先搜索实现标记操作。在下面的代码中，我们把标记过的字母 O 修改为字母 A。

class Solution {
    int nr;
    int nc;

    public void dfs(char[][] board, int r, int c) {
        if (r < 0 || c < 0 || r >= nr || c >= nc || board[r][c] != 'O') {
            return;
        }
        // 将访问过的元素标记为M
        board[r][c] = 'M';
        dfs(board, r + 1, c);
        dfs(board, r - 1, c);
        dfs(board, r, c + 1);
        dfs(board, r, c - 1);
    }

    public void solve(char[][] board) {
        if (board == null || board.length == 0) {
            return;
        }
        nr = board.length;
        nc = board[0].length;
        // 遍历第一列和最后一列，以边界上的O为起点，标记所有与它直接或间接相连的字母O；
        for (int r = 0; r < nr; r++) {
            dfs(board, r, 0);
            dfs(board, r, nc - 1);
        }
        // 遍历第一行和最后一行，以边界上的O为起点，标记所有与它直接或间接相连的字母O；
        for (int c = 0; c < nc; c++) {
            dfs(board, 0, c);
            dfs(board, nr - 1, c);
        }
        for (int r = 0; r < nr; r++) {
            for (int c = 0; c < nc; c++) {
                // 如果该字母被标记过，则该字母为没有被字母 X 包围的字母 O，还原为字母 O
                if (board[r][c] == 'M') {
                    board[r][c] = 'O';
                // 如果该字母没有被标记过，则该字母为被字母 X 包围的字母 O，修改为字母X
                } else if (board[r][c] == 'O') {
                    board[r][c] = 'X';
                }
            }
        }
    }
}

463. 岛屿的周长

题目

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。

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

岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
在这里插入图片描述
输入：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

解法

公式法

一块土地原则上会带来 4 个周长，但岛上的土地存在接壤，每一条接壤，会减掉 2 个边长。

所以，总周长 = 4 * 土地个数 - 2 * 接壤边的条数。

遍历矩阵，遍历到土地，就 land++，如果它的右/下边也是土地，则 border++，遍历结束后代入公式。
在这里插入图片描述

public int islandPerimeter(int[][] grid) {
        int nr = grid.length;
        int nc = grid[0].length;
        // 土壤个数
        int land = 0;
        // 接壤边界的个数
        int border = 0;
        for (int r = 0; r < nr; r++) {
            for (int c = 0; c < nc; c++) {
                if (grid[r][c] == 1) {
                    // 计算土壤个数
                    land++;
                    // 如果右边是土地，则边界数+1
                    if (r + 1 < nr && grid[r + 1][c] == 1) {
                        border++;
                    }
                    // 如果下边是土地，则边界数+1
                    if (c + 1 < nc && grid[r][c + 1] == 1) {
                        border++;
                    }
                }
            }
        }
        // 每多一条接壤边就减少了2个边长
        return 4 * land - 2 * border;
    }

DFS

695. 岛屿的最大面积

题目

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。

解法

深度优先搜索

确定网格中每个连通形状的面积，然后取最大值。
如果在一个土地上，以4个方向探索与之项链的每一个土地(以及与这些土地相连的土地)。那么探索过的土地总数就是该连通形状的面积
为了确保每个土地都只访问不超过一次，在每经过一个土地时，将这个土地的值置为0。这样就不会多次访问同一个土地。

class Solution {
    int nr;
    int nc;

    public int maxAreaOfIsland(int[][] grid) {
        int ans = 0;
        nr = grid.length;
        nc = grid[0].length;
        for (int r = 0; r < nr; r++) {
            for (int c = 0; c < nc; c++) {
                ans = Math.max(ans, dfs(grid, r, c));
            }
        }
        return ans;
    }

    public int dfs(int[][] grid, int r, int c) {
        if (r < 0 || c < 0 || r >= nr || c >= nc || grid[r][c] != 1) {
            return 0;
        }
        // 每经过一块土地，将该土地的值置为0，标记为已经访问过
        grid[r][c] = 0;
        // ans = 1表示最开始
        int ans = 1;
        // 向四个方向探索
        ans += dfs(grid, r + 1, c);
        ans += dfs(grid, r - 1, c);
        ans += dfs(grid, r, c + 1);
        ans += dfs(grid, r, c - 1);
        return ans;
    }
}

733. 图像渲染

题目

733. 图像渲染

有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。

最后返回经过上色渲染后的图像。

示例 1:

输入:
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2

输出: [[2,2,2],[2,2,0],[2,0,1]]

解析:
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。

解法

深度优先搜索

饥渴的小苹果

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【DFS】200. 岛屿数量 & 130. 被围绕的区域 & 463. 岛屿的周长 & 695. 岛屿的最大面积 & 733. 图像渲染

200. 岛屿数量题目200. 岛屿数量给你一个由 ‘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：输入：g
复制链接

扫一扫