专题五：FloodFill 算法

lvo
214 阅读15分钟

1 图像渲染

1.1 题目链接

733. 图像渲染

1.2 题目描述

有一幅以 m x n 的二维整数数组表示的图画 image ，其中 image[i][j] 表示该图画的像素值大小。

你也被给予三个整数 sr ,  sc 和 newColor 。你应该从像素 image[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，因为它不是在上下左右四个方向上与初始点相连的像素点。

示例 2:

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

 

提示:

  • m == image.length
  • n == image[i].length
  • 1 <= m, n <= 50
  • 0 <= image[i][j], newColor < 216
  • 0 <= sr < m
  • 0 <= sc < n

1.3 解法

算法思路：

可以利⽤「深搜」或者「宽搜」，遍历到与该点相连的所有「像素相同的点」，然后将其修改成指定的像素即可。

递归函数设计：

参数：

  • a. 原始矩阵；
  • b. 当前所在的位置；
  • c. 需要修改成的颜⾊。

函数体：

  • a. 先将该位置的颜⾊改成指定颜⾊（因为我们的判断，保证每次进⼊递归的位置都是需要修改的位置）；
  • b. 遍历四个⽅向上的位置：
    • 如果当前位置合法，并且与初试颜⾊相同，就递归进去。

1.4 C++算法代码：

class Solution {
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
    int prev;
public:
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
        if(image[sr][sc] == color) return image;
        m = image.size(), n = image[0].size();
        prev = image[sr][sc];
        dfs(image, sr, sc, color);
        return image;
    }

    void dfs(vector<vector<int>>& image, int i, int j, int color)
    {
        image[i][j] = color;

        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && image[x][y] == prev)
            {
                dfs(image, x, y, color);
            }
        }
    }
};

2 岛屿数量

2.1 题目链接

200. 岛屿数量

2.2 题目描述

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

 

提示：

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 300
  • grid[i][j] 的值为 '0' 或 '1'

2.3 解法

算法思路：

遍历整个矩阵，每次找到「⼀块陆地」的时候：

  • 说明找到「⼀个岛屿」，记录到最终结果 ret ⾥⾯；
  • 并且将这个陆地相连的所有陆地，也就是这块「岛屿」，全部「变成海洋」。这样的话，我们下次遍历到这块岛屿的时候，它「已经是海洋」了，不会影响最终结果。
  • 其中「变成海洋」的操作，可以利⽤「深搜」和「宽搜」解决，其实就是 733. 图像渲染 这道题~

这样，当我们，遍历完全部的矩阵的时候， ret 存的就是最终结果。

算法流程：

  1. 初始化 ret = 0 ，记录⽬前找到的岛屿数量;
  2. 双重循环遍历⼆维⽹格，每当遇到⼀块陆地，标记这是⼀个新的岛屿，然后将这块陆地相连的陆地全部变成海洋。

递归函数的设计：

  1. 把当前格⼦标记为⽔；
  2. 向上、下、左、右四格递归寻找陆地，只有在下标位置合理的情况下，才会进⼊递归：
    • a. 下⼀个位置的坐标合理；
    • b. 并且下一个位置是陆地

2.4 C++算法代码：

class Solution {
    vector<vector<bool>> vis;
    int m, n;
public:
    int numIslands(vector<vector<char>>& grid) {
        m = grid.size(), n = grid[0].size();
        vis = vector<vector<bool>>(m,vector<bool>(n));

        int ret = 0;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(!vis[i][j] && grid[i][j] == '1')
                {
                    ret++;
                    dfs(grid, i, j);
                }
            }
        }
        return ret;
    }

    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};   

    void dfs(vector<vector<char>>& grid,int i, int j)
    {
        vis[i][j] = true;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] == '1')
            {
                dfs(grid, x, y);
            }
        }
    }
};

3 岛屿的最大面积

3.1 题目链接

695. 岛屿的最大面积

3.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

 

提示：

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 50
  • grid[i][j] 为 0 或 1

3.3 解法（深搜 dfs）：

算法思路：

  • 遍历整个矩阵，每当遇到⼀块⼟地的时候，就⽤「深搜」或者「宽搜」将与这块⼟地相连的「整个岛屿」的⾯积计算出来。
  • 然后在搜索得到的「所有的岛屿⾯积」求⼀个「最⼤值」即可。
    • 在搜索过程中，为了「防⽌搜到重复的⼟地」：
    • 可以开⼀个同等规模的「布尔数组」，标记⼀下这个位置是否已经被访问过；
    • 也可以将原始矩阵的 1 修改成 0 ，但是这样操作会修改原始矩阵。

算法流程：

  • 主函数内：
    • a. 遍历整个数组，发现⼀块没有遍历到的⼟地之后，就⽤ dfs ，将与这块⼟地相连的岛屿的⾯积求出来；
    • b. 然后将⾯积更新到最终结果 ret 中。
  • 深搜函数 dfs 中：
    • a. 能够进到 dfs 函数中，说明是⼀个没遍历到的位置；
    • b. 标记⼀下已经遍历过，设置⼀个变量 S = 1 （当前这个位置的⾯积为 1 ），记录最终的⾯积；
    • c. 上下左右遍历四个位置：
      • 如果找到⼀块没有遍历到的⼟地，就将与这块⼟地相连的岛屿⾯积累加到 S 上；
    • d. 循环结束后， S 中存的就是整块岛屿的⾯积，返回即可。

3.4 C++算法代码：

class Solution {
    bool vis[51][51];
    int m, n;
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int count;
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        m = grid.size(), n = grid[0].size();

        int ret = 0;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(!vis[i][j] && grid[i][j] == 1)
                {
                    count = 0;
                    dfs(grid, i, j);
                    ret = max(ret, count);
                }
            }
        }
        return ret;
    }

    void dfs(vector<vector<int>>& grid, int i, int j)
    {
        count++;
        vis[i][j] = true;

        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] == 1)
            {
                dfs(grid, x, y);
            }
        }
    }
};

4 被围绕的区域

4.1 题目链接

130. 被围绕的区域

4.2 题目描述

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' 组成，捕获 所有 被围绕的区域：

  • 连接： 一个单元格与水平或垂直方向上相邻的单元格连接。
  • 区域：连接所有 'O' 的单元格来形成一个区域。
  • 围绕： 如果您可以用 'X' 单元格 连接这个区域，并且区域中没有任何单元格位于 board 边缘，则该区域被 'X' 单元格围绕。

通过将输入矩阵 board 中的所有 '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"]]

解释：

在上图中，底部的区域没有被捕获，因为它在 board 的边缘并且不能被围绕。

示例 2：

输入： board = [["X"]]

输出： [["X"]]

 

提示：

  • m == board.length
  • n == board[i].length
  • 1 <= m, n <= 200
  • board[i][j] 为 'X' 或 'O'

4.3 解法

算法思路：

正难则反。

可以先利⽤ dfs 将与边缘相连的 '0' 区域做上标记，然后重新遍历矩阵，将没有标记过的 '0'修改成 'X' 即可。

4.4 C++算法代码：

class Solution {
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
public:
    void solve(vector<vector<char>>& board) {
        m = board.size(), n = board[0].size();

        // 1. 把边界的 0 项链的联通块， 全部修改成 '.'
        for(int i = 0; i < m; i++)
        {
            if(board[i][0] == 'O') dfs(board, i, 0);
            if(board[i][n - 1] == 'O') dfs(board, i, n - 1);
        }
        for(int j = 0; j < n; j++)
        {
            if(board[0][j] == 'O') dfs(board, 0, j);
            if(board[m - 1][j] == 'O') dfs(board, m - 1, j);
        }

        // 2. 还原
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(board[i][j] == '.') board[i][j] = 'O';
                else if(board[i][j] == 'O') board[i][j] = 'X';
            }
        }
    }
    void dfs(vector<vector<char>>& board, int i, int j)
    {
        board[i][j] = '.';
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O')
            {
                dfs(board, x, y);
            }
        }
    }
};

5 太平洋大西洋水流问题

5.1 题目链接

417. 太平洋大西洋水流问题

5.2 题目描述

有一个 m × n 的矩形岛屿，与 太平洋 和 大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界，而  “大西洋”  处于大陆的右边界和下边界。

这个岛被分割成一个由若干方形单元格组成的网格。给定一个 m x n 的整数矩阵 heights ， heights[r][c] 表示坐标 (r, c) 上单元格 高于海平面的高度 。

岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。

返回网格坐标 result 的 2D 列表 ，其中 result[i] = [ri, ci] 表示雨水从单元格 (ri, ci) 流动 既可流向太平洋也可流向大西洋 。

 

示例 1：

输入: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]
输出: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]

示例 2：

输入: heights = [[2,1],[1,2]]
输出: [[0,0],[0,1],[1,0],[1,1]]

 

提示：

  • m == heights.length
  • n == heights[r].length
  • 1 <= m, n <= 200
  • 0 <= heights[r][c] <= 105

5.3 解法

算法思路：

正难则反。

如果直接去判断某⼀个位置是否既能到⼤西洋也能到太平洋，会重复遍历很多路径。

我们反着来，从⼤西洋沿岸开始反向 dfs ，这样就能找出哪些点可以流向⼤西洋；同理，从太平洋沿岸也反向 dfs ，这样就能找出哪些点可以流向太平洋。那么，被标记两次的点，就是我们要找的结果。

5.4 C++算法代码：

class Solution {
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
public:
    vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
        m = heights.size(), n = heights[0].size();
        vector<vector<bool>> pac(m,vector<bool>(n));
        vector<vector<bool>> atl(m,vector<bool>(n));

        // 1. 先处理 pac 
        for(int j = 0; j < n; j++) dfs(heights, 0, j, pac);
        for(int i = 0; i < m; i++) dfs(heights, i, 0, pac);

        // 2. 处理 atl
        for(int j = 0; j < n; j++) dfs(heights, m - 1, j, atl);
        for(int i = 0; i < m; i++) dfs(heights, i, n - 1, atl);

        vector<vector<int>> ret;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(pac[i][j] && atl[i][j])
                    ret.push_back({i, j});
        return ret;
    }
    void dfs(vector<vector<int>>& heights, int i, int j, vector<vector<bool>>& vis)
    {
        vis[i][j] = true;
        for(int k = 0; k < 4; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && heights[x][y] >= heights[i][j])
            {
                dfs(heights, x, y, vis);
            }
        }
    }
};

6 扫雷游戏

6.1 题目链接

529. 扫雷游戏

6.2 题目描述

让我们一起来玩扫雷游戏！

给你一个大小为 m x n 二维字符矩阵 board ，表示扫雷游戏的盘面，其中：

  • 'M' 代表一个 未挖出的 地雷，
  • 'E' 代表一个 未挖出的 空方块，
  • 'B' ****代表没有相邻（上，下，左，右，和所有4个对角线）地雷的 已挖出的 空白方块，
  • 数字（'1' 到 '8'）表示有多少地雷与这块 已挖出的 方块相邻，
  • 'X' 则表示一个 已挖出的 地雷。

给你一个整数数组 click ，其中 click = [clickr, clickc] 表示在所有 未挖出的 方块（'M' 或者 'E'）中的下一个点击位置（clickr 是行下标，clickc 是列下标）。

根据以下规则，返回相应位置被点击后对应的盘面：

  1. 如果一个地雷（'M'）被挖出，游戏就结束了- 把它改为 'X' 。
  2. 如果一个 没有相邻地雷 的空方块（'E'）被挖出，修改它为（'B'），并且所有和其相邻的 未挖出 方块都应该被递归地揭露。
  3. 如果一个 至少与一个地雷相邻 的空方块（'E'）被挖出，修改它为数字（'1' 到 '8' ），表示相邻地雷的数量。
  4. 如果在此次点击中，若无更多方块可被揭露，则返回盘面。

 

示例 1：

输入： board = [["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]], click = [3,0]
输出： [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]

示例 2：

输入： board = [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]], click = [1,2]
输出： [["B","1","E","1","B"],["B","1","X","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]

 

提示：

  • m == board.length
  • n == board[i].length
  • 1 <= m, n <= 50
  • board[i][j] 为 'M'、'E'、'B' 或数字 '1' 到 '8' 中的一个
  • click.length == 2
  • 0 <= clickr < m
  • 0 <= clickc < n
  • board[clickr][clickc] 为 'M' 或 'E'

6.3 解法

算法思路：

模拟类型的 dfs 题⽬。

⾸先要搞懂题⽬要求，也就是游戏规则。

从题⽬所给的点击位置开始，根据游戏规则，来⼀次 dfs 即可。

6.4 C++算法代码：

class Solution {
    int dx[8] = {0, 0, 1, -1, 1, 1, -1, -1};
    int dy[8] = {1, -1, 0, 0, 1, -1, 1, -1};
    int m, n;

public:
    vector<vector<char>> updateBoard(vector<vector<char>>& board,vector<int>& click) 
    {
        m = board.size(), n = board[0].size();
        int x = click[0], y = click[1];
        if (board[x][y] == 'M') // 直接点到地雷
        {
            board[x][y] = 'X';
            return board;
        }
        dfs(board, x, y);
        return board;
    }
    void dfs(vector<vector<char>>& board, int i, int j) 
    {
        // 统计一下周围地雷的个数
        int count = 0;
        for (int k = 0; k < 8; k++) {
            int x = i + dx[k], y = j + dy[k];
            if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'M') 
            {
                count++;
            }
        }
        if (count) // 周围有地雷
        {
            board[i][j] = count + '0';
            return;
        } 
        else // 周围没有地雷
        {
            board[i][j] = 'B';
            for (int k = 0; k < 8; k++)
            {
                int x = i + dx[k], y = j + dy[k];
                if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'E') 
                {
                    dfs(board, x, y);
                }
            }
        }
    }
};

7 衣橱整理

7.1 题目链接

LCR 130. 衣橱整理

7.2 题目描述

家居整理师将待整理衣橱划分为 m x n 的二维矩阵 grid，其中 grid[i][j] 代表一个需要整理的格子。整理师自 grid[0][0] 开始 逐行逐列 地整理每个格子。

整理规则为：在整理过程中，可以选择 向右移动一格 或 向下移动一格，但不能移动到衣柜之外。同时，不需要整理 digit(i) + digit(j) > cnt 的格子，其中 digit(x) 表示数字 x 的各数位之和。

请返回整理师 总共需要整理多少个格子。

 

示例 1：

输入： m = 4, n = 7, cnt = 5
输出： 18

 

提示：

  • 1 <= n, m <= 100
  • 0 <= cnt <= 20

7.3 解法（dfs）：

算法思路：

这是⼀道⾮常典型的「搜索」类问题。

我们可以通过「深搜」或者「宽搜」，从 [0, 0] 点出发，按照题⽬的「规则」⼀直往 [m - 1,n - 1] 位置⾛。

同时，设置⼀个全局变量。每次⾛到⼀个合法位置，就将全局变量加⼀。当我们把所有能⾛到的路都⾛完之后，全局变量⾥⾯存的就是最终答案。

算法流程：

  • 递归函数设计：
    • a. 参数：当前所在的位置 [i, j] ，⾏⾛的边界 [m, n] ，坐标数位之和的边界 k ；
    • b. 递归出⼝：
      • i. [i, j] 的坐标不合法，也就是已经超出能⾛的范围；
      • ii. [i, j] 位置已经⾛过了（因此我们需要创建⼀个全局变量 bool st[101][101] ，来标记当前位置是否⾛过）；
      • iii. [i, j] 坐标的数位之和⼤于 k ；
    • 上述情况的任何⼀种都是递归出⼝。
    • c. 函数体内部：
      • i. 如果这个坐标是合法的，就将全局变量 ret++ ；
      • ii. 然后标记⼀下 [i, j] 位置已经遍历过；
      • iii. 然后去 [i, j] 位置的上下左右四个⽅向去看看。
  • 辅助函数：
    • a. 检测坐标 [i, j] 是否合法；
    • b. 计算出 i，j 的数位之和，然后与 k 作⽐较即可。
  • 主函数：
    • a. 调⽤递归函数，从 [0 ,0] 点出发。
  • 辅助的全局变量：
    • a. ⼆维数组 bool st[101][101] ：标记 [i, j] 位置是否已经遍历过；
    • b. 变量 ret ：记录⼀共到达多少个合法的位置。
    • c. 上下左右的四个坐标变换。

7.4 C++算法代码：

class Solution {
    int m, n, k;
    bool vis[101][101];
    int ret;
    int dx[2] = {1, 0};
    int dy[2] = {0, 1};
public:
    int wardrobeFinishing(int _m, int _n, int _cnt) {
        m = _m, n = _n, k = _cnt;
        dfs(0,0);
        return ret; 
    }
    void dfs(int i, int j)
    {
        ret++;
        vis[i][j] = true;
        for(int k = 0; k < 2; k++)
        {
            int x = i + dx[k], y = j + dy[k];
            if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && check(x, y))
            {
                dfs(x, y);
            }
        }
    }
    bool check(int i, int j)
    {
        int tmp = 0;
        while(i)
        {
            tmp += i % 10;
            i /=10;
        }
        while(j)
        {
            tmp += j % 10;
            j /= 10;
        }
        return tmp <= k;
    }
};
avatar
文章
阅读
粉丝