算法沉淀——FloodFill 算法
- 01.图像渲染
- 02.岛屿数量
- 03.岛屿的最大面积
- 04.被围绕的区域
- 05.太平洋大西洋水流问题
- 06.扫雷游戏
- 07.衣橱整理
Flood Fill(泛洪填充)算法是一种图像处理的基本算法,用于填充连通区域。该算法通常从一个种子点开始,沿着种子点的相邻像素进行填充,直到遇到边界或者其他指定的条件为止。Flood Fill 算法的主要应用是在图像编辑软件中实现填充操作,以及在计算机图形学、计算机视觉等领域中进行区域填充。
算法的基本思想是:
- 选择一个起始点(种子点),将其染色。
- 检查当前点的相邻像素,如果符合填充条件且未被染色,则将其染色,并将其加入待处理队列(或递归调用)。
- 重复步骤2,直到没有可填充的像素为止。
Flood Fill 算法的实现可以使用递归、栈或队列等数据结构。常见的填充条件包括相邻像素颜色相同、相邻像素颜色不同等。
在图像编辑软件中,用户通常通过选择一个起始点和指定填充颜色来触发 Flood Fill 操作,使得相邻区域被填充为指定颜色。
Flood Fill 算法的变种和优化版本也被用于解决其他问题,例如计算连通区域的大小、边界填充、种子点选择策略等。
01.图像渲染
题目链接:https://leetcode.cn/problems/flood-fill/
有一幅以 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 {const int dx[4]={0,0,1,-1};const int dy[4]={-1,1,0,0};int m,n,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 sr, int sc, int color){image[sr][sc]=color;for(int i=0;i<4;++i){int x=sr+dx[i],y=sc+dy[i];if(x>=0&&x<m&&y>=0&&y<n&&image[x][y]==prev){dfs(image,x,y,color);}}}
};
02.岛屿数量
题目链接:https://leetcode.cn/problems/number-of-islands/
给你一个由 '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'
思路
结合前面的题目,我们只需要对每个等于1的格子进行一次深度遍历,遍历过后标记该位置,防止重新标记。
代码
class Solution {const int dx[4]={0,0,1,-1};const int dy[4]={1,-1,0,0};int m,n;bool vis[301][301];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);}}}
public:int numIslands(vector<vector<char>>& 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'){ret++;dfs(grid,i,j);}}}return ret;}
};
03.岛屿的最大面积
题目链接:https://leetcode.cn/problems/max-area-of-island/
给你一个大小为 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
思路
在解决这个问题时,我们可以遍历整个矩阵,每当遇到一块土地时,使用深度搜索(DFS)或宽度搜索(BFS)将与这块土地相连的整个岛屿的面积计算出来。然后,在搜索得到的所有岛屿面积中求一个最大值即可。
在搜索过程中,为了防止搜到重复的土地,可以采用以下两种方法之一:
- 开一个同等规模的布尔数组,标记这个位置是否已经被访问过;
- 将原始矩阵的 1 修改成 0,但是这样操作会修改原始矩阵。
这样的搜索过程能够找到所有相连的土地形成的岛屿,并求出它们的面积,最后取得所有岛屿的最大面积。
代码
class Solution {const int dx[4]={0,0,1,-1};const int dy[4]={-1,1,0,0};bool vis[51][51];int m,n,count;void dfs(vector<vector<int>>& grid,int i,int j){vis[i][j]=true;count++;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);}}}
public:int maxAreaOfIsland(vector<vector<int>>& grid) {int ret=0;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){count=0;dfs(grid,i,j);ret=max(ret,count);} }}return ret;}
};
04.被围绕的区域
题目链接:https://leetcode.cn/problems/surrounded-regions/
给你一个 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'
思路
这里我们采用逆向思维的方式,先从四周开始深度遍历,将能遍历到的O都改为除X之外的字符,那么剩下的字符O就是需要修改的字符了,之后再遍历棋盘,将改为其他字符的字符改回O,将需要修改的O改为X。
代码
class Solution {const int dx[4]={0,0,1,-1};const int dy[4]={-1,1,0,0};int m,n;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'){board[x][y]='#';dfs(board,x,y);}}}
public:void solve(vector<vector<char>>& board) {m=board.size(),n=board[0].size();for(int i=0;i<n;++i){if(board[0][i]=='O') dfs(board,0,i);if(board[m-1][i]=='O') dfs(board,m-1,i);}for(int i=1;i<m-1;++i){if(board[i][0]=='O') dfs(board,i,0);if(board[i][n-1]=='O') dfs(board,i,n-1);}for(int i=0;i<m;i++){for(int j=0;j<n;j++){if(board[i][j]=='O') board[i][j]='X';else if(board[i][j]=='#') board[i][j]='O';}}}
};
05.太平洋大西洋水流问题
题目链接:https://leetcode.cn/problems/pacific-atlantic-water-flow/
有一个 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
思路
和上面一样,这里我们采用逆向思维,从太平洋和大西洋两边的边向上遍历,比自己本身大就向上遍历,最后两边遍历完重叠区域即为所求。
代码
class Solution {const int dx[4]={0,0,1,-1};const int dy[4]={1,-1,0,0};bool po[201][201];bool ao[201][201];int m,n;
public:vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {m=heights.size(),n=heights[0].size();vector<vector<int>> ret;for(int i=0;i<n;++i) dfs(heights,0,i,po);for(int i=0;i<m;++i) dfs(heights,i,0,po);for(int i=0;i<m;++i) dfs(heights,i,n-1,ao);for(int i=0;i<n;++i) dfs(heights,m-1,i,ao);for(int i=0;i<m;i++)for(int j=0;j<n;++j)if(po[i][j]&&ao[i][j]) ret.push_back({i,j});return ret;}void dfs(vector<vector<int>>& heights,int i,int j,bool vis[201][201]){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);}}
};
06.扫雷游戏
题目链接:https://leetcode.cn/problems/minesweeper/
让我们一起来玩扫雷游戏!
给你一个大小为 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的过程中,根据题目规定的游戏规则,进行相应的操作。
07.衣橱整理
题目链接:https://leetcode.cn/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof/
家居整理师将待整理衣橱划分为 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
思路
在原始的dfs基础上加上一个边界条件,即不可超过的范围即可。
代码
class Solution {const int dx[4]={0,0,1,-1};const int dy[4]={1,-1,0,0};int m,n,c,ret=0;bool vis[101][101];
public:int wardrobeFinishing(int _m, int _n, int cnt) {m=_m,n=_n,c=cnt;dfs(0,0);return ret;}void dfs(int i,int j){vis[i][j]=true;ret++;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]&&comp(x,y))dfs(x,y);}}bool comp(int i,int j){int tmp=0;while(i){tmp+=i%10;i/=10;}while(j){tmp+=j%10;j/=10;}return tmp<=c;}
};