✨ 君子坐而论道，少年起而行之 🌏
🔥个人专栏：算法训练
🚀 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞
引言
FloodFill （泛洪填充）算法是一种图像处理的基本算法，用于填充连通区域。该算法通常从一个种子点开始，沿着种子点的相邻像素进行填充，直到遇到边界或者其他指定的条件为止。FloodFill 算法的主要应用是在图像编辑软件中实现填充操作，以及在计算机图形学、计算机视觉等领域中进行区域填充。
- 基本作用：寻找连通块
- 基本方法：DFS（深度优先遍历）、BFS（广度优先遍历）
- 适用题目：需要找出分类块的题目/一些聚类问题/
-
本质问题：找出这块区域中性质相同的连通块
连通块可以使上下左右四个方向连同，也可以是加上斜向八个方向连通
算法的基本思想是：
- 选择一个起始点（种子点），将其染色。
- 检查当前点的相邻像素，如果符合填充条件且未被染色，则将其染色，并将其加入待处理队列（或递归调用）。
- 重复步骤2，直到没有可填充的像素为止。
Flood Fill 算法的实现可以使用递归、栈或队列等数据结构。常见的填充条件包括相邻像素颜色相同、相邻像素颜色不同等。
在图像编辑软件中，用户通常通过选择一个起始点和指定填充颜色来触发 Flood Fill 操作，使得相邻区域被填充为指定颜色。
Flood Fill 算法的变种和优化版本也被用于解决其他问题，例如计算连通区域的大小、边界填充、种子点选择策略等。
图解如下：找到负数相连连通块数目‘
下面我们通过一些题目来理解这个算法思想：
1. 图像渲染
思路：
我们从给定的起点开始，可以利用「深搜」或者「宽搜」（上下左右四个方向）。每次搜索到一个方格时，如果其与初始位置的方格颜色相同，就将该方格的颜色更新，如果不相同，则进行回溯。这里我们设置初始方格为target.
优化：
可以使用一个bool类型的数组来标记这个点是否被染色，以防止重复染色。
AC代码如下：
int dir[4][2] = {
{1,0},{0,1},{-1,0},{0,-1}
};
int n, m, target;
bool vis[105][105]; //标记该点是否用过
void dfs(vector<vector<int>>& image, int x, int y, int color){
image[x][y] = color;
vis[x][y] = true;
for (int i = 0; i < 4; i++) {
int dx = x + dir[i][0], dy = y + dir[i][1];
if (dx >= 0 && dx < m && dy >= 0 && dy < n && !vis[dx][dy] && image[dx][dy] == target)
dfs(image, dx, dy, color);
}
}
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();
target = image[sr][sc];
dfs(image, sr, sc, color);
return image;
}2. 岛屿数量
思路：
- 遍历整个矩阵，每次找到「⼀块陆地」的时候：
- 说明找到「⼀个岛屿」，记录到最终结果 res⾥⾯；
- 并且将这个陆地相连的所有陆地，也就是这块「岛屿」，全部「变成海洋」。这样的话，我们下次 遍历到这块岛屿的时候，它「已经是海洋」了，不会影响最终结果。
- 其中「变成海洋」的操作，可以利⽤「深搜」来解决
AC代码如下：
int dir[4][2] = {
{1,0},{0,1},{-1,0},{0,-1}
};
int n, m;
bool vis[505][505]; //标记该点是否用过
void dfs(vector<vector<char>>& grid, int x, int y){
vis[x][y] = true;
for (int i = 0; i < 4; i++) {
int dx = x + dir[i][0], dy = y + dir[i][1];
if (dx >= 0 && dx < m && dy >= 0 && dy < n && !vis[dx][dy] && grid[dx][dy] == '1')
{
dfs(grid, dx, dy);
}
}
}
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;
}3. 岛屿的最大面积
思路：
在解决这个问题时，我们可以遍历整个矩阵，每当遇到一块土地时，使用深度搜索（DFS）或宽度搜索（BFS）将与这块土地相连的整个岛屿的面积计算出来。然后，在搜索得到的所有岛屿面积中求一个最大值即可。
在搜索过程中，为了防止搜到重复的土地，可以采用以下两种方法之一：
- 开一个同等规模的布尔数组，标记这个位置是否已经被访问过；
- 将原始矩阵的 1 修改成 0，但是这样操作会修改原始矩阵。
这样的搜索过程能够找到所有相连的土地形成的岛屿，并求出它们的面积，最后取得所有岛屿的最大面积。
AC代码如下：
int dir[4][2] = {
{1,0},{0,1},{-1,0},{0,-1}
};
int n, m, cnt;
bool vis[505][505]; //标记该点是否用过
void dfs(vector<vector<int>>& grid, int x, int y){
vis[x][y] = true;
cnt++; //记录每块岛屿的面积
for (int i = 0; i < 4; i++) {
int dx = x + dir[i][0], dy = y + dir[i][1];
if (dx >= 0 && dx < m && dy >= 0 && dy < n && !vis[dx][dy] && grid[dx][dy] == 1)
{
dfs(grid, dx, dy);
}
}
}
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) {
cnt = 0;
dfs(grid, i, j);
ret = max(cnt, ret);
}
}
}
return ret;
}4. 被围绕的区域
思路：
正难则反。 这里我们采用逆向思维的方式，先从四周开始深度遍历，将能遍历到的 ‘O’ 做上标记，那么剩下的字符 ‘O’ 就是需要修改的字符了，之后再重新遍历棋盘，将没有标记的 ‘O’ 改为 ‘X’ 。
AC代码如下：
int dir[4][2] = {
{1,0},{0,1},{-1,0},{0,-1}
};
int n, m, cnt;
bool vis[505][505]; //标记该点是否用过
void dfs(vector<vector<char>>& grid, int i, int j){
vis[i][j] = true;
for (int k = 0; k < 4; k++) {
int x = i + dir[k][0], y = j + dir[k][1];
if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && grid[x][y] == 'O')
{
dfs(grid, x, y);
}
}
}
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' && !vis[i][j])
board[i][j] = 'X';
}
}
}5. 太平洋大西洋水流问题
思路：
题目本质：雨水只能从高的地方流向低的地方，求二维表格中哪些坐标的雨水既可以流入太平洋又可以流入大西洋。
和上面一样，这里我们也采用正难则反的思想。因为如果直接去判断某⼀个位置是否既能到⼤西洋也能到太平洋，会重复遍历很多路径。因此我们反着来，去从太平洋和大西洋两边的开始反向遍历，比自己本身大就继续向上遍历，最后两边都遍历完求重叠区域（即被标记两次的点），就是为我们要求的答案。
关于标记两次，我们用两个bool数组即可。
AC代码如下：
int dir[4][2] = {
{1,0},{0,1},{-1,0},{0,-1}
};
int n, m, cnt;
bool pac[505][505];
bool atl[505][505];
void dfs(vector<vector<int>>& heights, int i, int j, bool vis[][505]) {
vis[i][j] = true;
for (int k = 0; k < 4; k++) {
int x = i + dir[k][0], y = j + dir[k][1];
if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && heights[x][y] >= heights[i][j])
{
dfs(heights, x, y, vis);
}
}
}
vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
m = heights.size(), n = heights[0].size();
vector<vector<int>> ret;
// 1.太平洋的流入
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.大西洋的流入
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); //最后一列
// 3.求重叠区域
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;
}6. 扫雷游戏
AC代码如下：
思路：
模拟类型的深度优先搜索（DFS）题目。首先，需要理解题目的要求，即游戏规则。
从给定的点击位置开始，根据游戏规则执行一次深度优先搜索即可。在DFS的过程中，如果当前遍历的格子没有地雷，就往下遍历，如果有，就显示附近地雷的数量，然后递归返回。
注意：八个方向都可以扩展
int dir[8][2] = {
{1,0},{0,1},{-1,0},{0,-1},
{-1,-1},{-1,1},{1,-1},{1,1}
};
int n, m;
void dfs(vector<vector<char>>& board, int i, int j)
{
// 1. 统计以下周围地雷个数
int cnt = 0;
for (int k = 0; k < 8; k++)
{
int x = i + dir[k][0], y = j + dir[k][1];
if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'M')
{
cnt++;
}
}
// 2.周围有地雷
if (cnt)
{
board[i][j] = cnt + '0'; //显示附近地雷数量
return;
}
else // 3.周围没地雷，则往八个方向进行扩展
{
board[i][j] = 'B';//周围没地雷时，自己标记为B
for (int k = 0; k < 8; k++) {
int x = i + dir[k][0], y = j + dir[k][1];
if (x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'E')
{
dfs(board, x, y);
}
}
}
}
vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click)
{
m = board.size(), n = board[0].size();
int sx = click[0], sy = click[1]; //起始位置
if (board[sx][sy] == 'M')
{
board[sx][sy] = 'X'; //扫到地雷直接退出
return board;
}
dfs(board, sx, sy);
return board;
}7. 衣橱整理
思路：
在原始的dfs基础上加上一个边界条件，即不可超过的范围即可。
AC代码如下：
int dir[4][2] = {
{1,0},{0,1},{-1,0},{0,-1},
};
int n, m, cnt, ret = 0;
bool vis[505][505];
int digit(int x) //x的数位之和额外的条件，
{
int ans = 0;
while (x)
{
ans += x % 10;
x /= 10;
}
return ans;
}
void dfs(int i, int j){
vis[i][j] = true;
ret++;
for (int k = 0; k < 4; k++) {
int x = i + dir[k][0], y = j + dir[k][1];
if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && (digit(x) + digit(y) <= cnt))//不整理digit(x) + digit(y) > cnt;
{
dfs(x, y);
}
}
}
int wardrobeFinishing(int _m, int _n, int _cnt) {
m = _m, n = _n, cnt = _cnt; //改成全局变量存储
dfs(0, 0); //从（0，0）开始整理
return ret;
}8. 城市群数量
思路：
正常的连通问题，dfs加标记即可
AC代码如下：（dfs解法）
int n;
bool vis[210] = { 0 }; //标记当前位置释放被搜过
void dfs(vector<vector<int>>& m, int pos){
vis[pos] = true; //连通城市
for (int i = 0; i < n; i++) {
if (!vis[i] && m[pos][i] == 1) {
dfs(m, i);
}
}
}
int citys(vector<vector<int> >& m) {
n = m.size();
int ret = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
ret++; //记录城市群数量
dfs(m, i);
}
}
return ret;
}
7012
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
