- 1自定义UITabBarController Swift_自定义 uitabbarcontroller swift
- 2Houdini流体＞＞粒子流体导出到unity笔记_houdini vat unity
- 3mysql数据库之事务_mysql 事务
- 4PostgreSQL定期清理归档(pg_wal)日志
- 5maven打包把git版本号打包进去_maven package版本号打进去
- 6dotnet 的跨平台 UI 框架：WPF 的精神继承 | 开源日报 No.123_.net wpf ui框架
- 7机器学习常用代码_机器学习代码
- 8Unity学习笔记（二）无代码做个2D游戏_unity开发2d游戏方便吗
- 9Python with和contextlib.closing配合使用（contextlib）
- 10python处理wav音频文件：音频信息，读取内容，获取时长，切割音频，pcm与wav互转_python 读写 wav 时长
【算法专题】FloodFill 算法
赞
踩
FloodFill 算法
1. 图像渲染
题目链接 -> Leetcode -773.图像渲染
Leetcode -773.图像渲染
题目：有一幅以 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
思路：利用深搜，遍历到与该点相连的所有「像素相同的点」，然后将其修改成指定的像素即可。
代码如下：
class Solution { int dx[4] = {0, 0, 1, -1}; int dy[4] = {-1, 1, 0, 0}; int m, n; 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(); dfs(image, sr, sc, color, image[sr][sc]); // 最后更改入口坐标的颜色 image[sr][sc] = color; return image; } void dfs(vector<vector<int>>& image, int row, int col, int newcolor, int color) { image[row][col] = newcolor; // 更改颜色 // 判断当前位置上下左右位置 for(int k = 0; k < 4; k++) { int x = row + dx[k], y = col + dy[k]; if(x >= 0 && x < m && y >= 0 && y < n && image[x][y] == color) { dfs(image, x, y, newcolor, color); } } } };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
2. 岛屿数量
题目链接 -> Leetcode -200.岛屿数量
Leetcode -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
提示：
- m == grid.length
- n == grid[i].length
- 1 <= m, n <= 300
- grid[i][j] 的值为 ‘0’ 或 ‘1’
思路：遍历整个矩阵，每次找到「一块陆地」的时候：
- 说明找到「一个岛屿」，记录到最终结果 ret 里面；
- 并且将这个陆地相连的所有陆地，也就是这块「岛屿」，全部「变成海洋」。这样的话，我们下次遍历到这块岛屿的时候，它「已经是海洋」了，不会影响最终结果。
- 其中「变成海洋」的操作，可以利用「深搜」和「宽搜」解决，其实就是 图像渲染 这道题了
这样，当我们，遍历完全部的矩阵的时候， ret 存的就是最终结果。
代码如下：
class Solution { int dx[4] = {0, 0, -1, 1}; int dy[4] = {1, -1, 0, 0}; vector<vector<bool>> vis; int m, n; public: int numIslands(vector<vector<char>>& grid) { int ret = 0; m = grid.size(), n = grid[0].size(); vis.resize(m, vector<bool>(n)); for(int i = 0; i < m; i++) { for(int j = 0; j < n; j++) { if(!vis[i][j] && grid[i][j] == '1') { // 以 i，j 为岛屿中心开始扩散，统计岛屿数量 ret++; dfs(grid, i, j); } } } return ret; } void dfs(vector<vector<char>>& grid, int row, int col) { vis[row][col] = true; for(int k = 0; k < 4; k++) { int x = row + dx[k], y = col + dy[k]; if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] == '1') { dfs(grid, x, y); } } } };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
3. 岛屿的最大面积
题目链接 -> Leetcode -695.岛屿的最大面积
Leetcode -695.岛屿的最大面积
给你一个大小为 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
思路：
- 遍历整个矩阵，每当遇到一块土地的时候，就用「深搜」或者「宽搜」将与这块土地相连的「整个岛屿」的面积积计算出来。
- 然后在搜索得到的「所有的岛屿面积」求一个「最大值」即可。
- 在搜索过程中，为了「防止搜到重复的土地」：
可以开一个同等规模的「布尔数组」，标记一下这个位置是否已经被访问过；也可以将原始矩阵的 1 修改成 0 ，但是这样操作会修改原始矩阵。
代码如下：
class Solution { int dx[4] = {0, 0, -1, 1}; int dy[4] = {1, -1, 0, 0}; bool vis[50][50]; int ret, m, n, area; public: int maxAreaOfIsland(vector<vector<int>>& grid) { m = grid.size(), n = grid[0].size(); for(int i = 0; i < m; i++) { for(int j = 0; j < n; j++) { if(!vis[i][j] && grid[i][j] == 1) { area = 0; vis[i][j] = true; dfs(grid, i, j); ret = max(ret, area); } } } return ret; } void dfs(vector<vector<int>>& grid, int row, int col) { area++; for(int k = 0; k < 4; k++) { int x = row + dx[k], y = col + dy[k]; if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] && !vis[x][y]) { vis[x][y] = true; dfs(grid, x, y); } } } };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
4. 被围绕的区域
题目链接 -> Leetcode -130.被围绕的区域
Leetcode -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”]]
提示：
- m == board.length
- n == board[i].length
- 1 <= m, n <= 200
- board[i][j] 为 ‘X’ 或 ‘O’
思路：正难则反，可以先利用 dfs 将与边缘相连的 ‘0’ 区域做上标记，然后重新遍历矩阵，将没有标记过的 '0’修改成 ‘X’ 即可。
代码如下：
class Solution { int m, n; int dx[4] = {0, 0, -1, 1}; int dy[4] = {-1, 1, 0, 0}; public: void solve(vector<vector<char>>& board) { m = board.size(), n = board[0].size(); // 1. 把边界的 'O' 相连的联通块，全部修改成 '.' 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); } 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); } // 2.还原，将 '.' 还原成 'O'；不是边界的'O'变成 'X' 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 row, int col) { board[row][col] = '.'; for(int k = 0; k < 4; k++) { int x = row + dx[k], y = col + dy[k]; if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O') dfs(board, x, y); } } };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
5. 太平洋大西洋水流问题
题目链接 -> Leetcode -417.太平洋大西洋水流问题
Leetcode -417.太平洋大西洋水流问题
题目：有一个 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] <= 10^5
思路：正难则反，如果直接去判断某一个位置是否既能到大西洋也能到太平洋，会重复遍历很多路径。所以我们反着来，从大西洋沿岸开始反向 dfs ，这样就能找出那些点可以流向大西洋；同理，从太平洋沿岸也反向 dfs ，这样就能找出那些点可以流向太平洋。那么，被标记两次的点，就是我们要找的结果。
代码如下：
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>> visA(m, vector<bool>(n)); vector<vector<bool>> visP(m, vector<bool>(n)); vector<vector<int>> ret; // 让太平洋和大西洋的水逆流，即对边界的单元格开始做dfs，分别标记 visA 和 visP 数组 for(int j = 0; j < n; j++) { dfs(heights, 0, j, visP); dfs(heights, m - 1, j, visA); } for(int i = 0; i < m; i++) { dfs(heights, i, 0, visP); dfs(heights, i, n - 1, visA); } // 最终遍历 visA 和 visP，如果都为 true，说明能流入两个洋，加入返回列表中 for(int i = 0; i < m; i++) { for(int j = 0; j < n; j++) { if(visA[i][j] && visP[i][j]) { ret.push_back({i, j}); } } } return ret; } void dfs(vector<vector<int>>& heights, int row, int col, vector<vector<bool>>& vis) { vis[row][col] = true; for(int k = 0; k < 4; k++) { int x = dx[k] + row, y = dy[k] + col; if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && heights[row][col] <= heights[x][y]) dfs(heights, x, y, vis); } } };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
6. 扫雷游戏
题目链接 -> Leetcode -529.扫雷游戏
Leetcode -529.扫雷游戏
题目：让我们一起来玩扫雷游戏！
给你一个大小为 m x n 二维字符矩阵 board ，表示扫雷游戏的盘面，其中：
- ‘M’ 代表一个 未挖出的 地雷，
- ‘E’ 代表一个 未挖出的 空方块，
- ‘B’ 代表没有相邻（上，下，左，右，和所有4个对角线）地雷的 已挖出的 空白方块，数字（‘1’ 到 ‘8’）表示有多少地雷与这块 已挖出的 方块相邻，
- ‘X’ 则表示一个 已挖出的 地雷。
给你一个整数数组 click ，其中 click = [clickr, clickc] 表示在所有 未挖出的 方块（‘M’ 或者 ‘E’）中的下一个点击位置（clickr 是行下标，clickc 是列下标）。
根据以下规则，返回相应位置被点击后对应的盘面：
- 如果一个地雷（‘M’）被挖出，游戏就结束了 - 把它改为 ‘X’ 。
- 如果一个 没有相邻地雷 的空方块（‘E’）被挖出，修改它为（‘B’），并且所有和其相邻的 未挖出 方块都应该被递归地揭露。
- 如果一个 至少与一个地雷相邻 的空方块（‘E’）被挖出，修改它为数字（‘1’ 到 ‘8’ ），表示相邻地雷的数量。
- 如果在此次点击中，若无更多方块可被揭露，则返回盘面。
示例 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’
思路：模拟类型的 dfs 题目；首先要搞懂题目要求，也就是游戏规则。从题目所给的点击位置开始，根据游戏规则，来一次 dfs 即可。
代码如下：
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 row, int col) { int count = 0; // 统计雷 for(int k = 0; k < 8; k++) { int x = row + dx[k], y = col + dy[k]; if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'M') { count++; } } // 如果周围有雷 if(count) { board[row][col] = count + '0'; return; } // 周围无雷 else { board[row][col] = 'B'; for(int k = 0; k < 8; k++) { int x = row + dx[k], y = col + dy[k]; if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'E') { dfs(board, x, y); } } } } };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
7. 衣橱整理
题目链接 -> Leetcode -LCR 130.衣橱整理
Leetcode -LCR 130.衣橱整理
题目：家居整理师将待整理衣橱划分为 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
思路：我们可以通过「深搜」，从 [0, 0] 点出发，按照题目的「规则」⼀直往 [m - 1, n - 1] 位置走。同时，设置⼀个全局变量。每次走到⼀个合法位置，就将全局变量加一。当我们把所有能走到的路都走完之后，全局变量里面存的就是最终答案。
代码如下：
class Solution { int dx[4] = {0, 0, -1, 1}; int dy[4] = {1, -1, 0, 0}; bool vis[100][100]; int ret; int m, n, k; public: int wardrobeFinishing(int _m, int _n, int _k) { m = _m, n = _n, k = _k; dfs(0, 0); return ret; } void dfs(int row, int col) { ret++; vis[row][col] = true; for(int k = 0; k < 4; k++) { int x = dx[k] + row, y = dy[k] + col; if(x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && Cheak(x, y)) { dfs(x, y); } } } bool Cheak(int x, int y) { int ret = 0; while(x > 0) { ret += x % 10; x /= 10; } while(y > 0) { ret += y % 10; y /= 10; } return ret > k? false : true; } };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
