文章目录
- 前言
- 什么是FloodFill算法
- 图像渲染
- 题目要求
- 题目解析
- 代码如下
- 岛屿数量
- 题目要求
- 题目解析
- 代码如下
- 岛屿的最大面积
- 题目要求
- 题目解析
- 代码如下
- 被围绕的区域
- 题目要求
- 题目解析
- 代码如下
前言
本文将会向你介绍宽度优先搜索解决FloodFill算法相关题型：图像渲染、岛屿数量、岛屿的最大面积、被围绕的区域
什么是FloodFill算法
FloodFill算法是一种用于图像处理和计算机图形学的算法，主要用于填充一个区域的颜色。它的基本思想是从一个起始点开始，检查该点的颜色，并将其替换为新的颜色，然后递归地检查相邻的像素（通常是上下左右四个方向），如果相邻的像素颜色与起始点的颜色相同，则继续填充。
图像渲染
https://leetcode.cn/problems/flood-fill/
题目要求
题目解析
题目要求将指定点周围（上下左右）同色（数字相同）的点改为指定的值（上色），接着再记录与刚上色的点上下左右同色的新的点，重复该过程…
这种有点像是内层一圈一圈向外发散的感觉
这里还是利用队列进行层序遍历，前面也有介绍过这种方法https://blog.csdn.net/Moonnight_bit/article/details/141967841?spm=1001.2014.3001.5501
不过还是有点区别的，就是我们需要对一个点的上下左右进行遍历，这里会用到两个数组，用来模拟一个点的上下左右位置（坐标系），比如一个点（0，0），dx[1], dy[1]为（1，0）在该点的右侧
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
注意两个点：
一、起初由一个点进行渲染，第二次渲染上下左右（蓝色），第三次同理（黄色）
这里需要注意的是，每次需要把渲染过的位置添加到队列中，这样才能从新渲染的位置出发进行下一次渲染
q.push({x, y});
if(x >= 0 && x < n && y >= 0 && y < m && image[x][y] == prev)
{}
代码如下
class Solution {
public:
vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color)
{
int prev = image[sr][sc];
if(prev == color) return image; //如果待渲染与当前位置颜色相同，直接返回即可
int n = image.size(), m = image[0].size();
//模拟坐标位置
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
queue<pair<int, int>> q; //层序遍历
q.push({sr, sc});
while(q.size())
{
auto[a, b] = q.front();
image[a][b] = color;
q.pop();
for(int i = 0; i < 4; i++)
{
int x = a + dx[i]; int y = b + dy[i];
//防止遍历上下左右时越界
if(x >= 0 && x < n && y >= 0 && y < m && image[x][y] == prev)
{
q.push({x, y});
}
}
}
return image;
}
};
岛屿数量
https://leetcode.cn/problems/number-of-islands/
题目要求
题目解析
1为陆地，0为水，岛屿是被水包围的，也就是找出1被0包围的区域，单个1也算是一块区域，多个1连在一起（上下左右）也算是一块区域
网格四条边均被水包围
我们可以像遍历一个二维数组，可以轻易地找到1和0
那么我们怎么能保证该岛屿只统计一次呢（遍历到的1所属岛屿是否已经统计过了？）
我们可以这么做
1、先遍历，找到一个1
2、将该1的坐标交给bfs宽度优先搜索，由bfs找到该1所属的整个岛屿，并标记已经记录过
以下代码的意思就是用vis数组标记该1是否已经作为岛屿的一部分统计过，!vis[i][j]，如果统计过，该位置就为true，！true就是false，表示已经统计过
3、当遍历完所有位置后，岛屿数量也就统计完了
bool vis[301][301];
if(grid[i][j] == '1' && !vis[i][j])
{
ret++;
vis[i][j] = true;
bfs(grid, i, j);
}
代码如下
class Solution {
public:
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
bool vis[301][301];
int ret = 0; //岛屿的数量
void bfs(vector<vector<char>>& grid, int i, int j)
{
queue<pair<int, int>> q;
q.push({i, j});
while(q.size())
{
auto [a, b] = q.front();
q.pop();
for(int k = 0; k < 4; k++)
{
int x = a + dx[k], y = b + dy[k];
if(x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size() && grid[x][y] == '1' && !vis[x][y])
{
q.push({x, y});
vis[x][y] = true;
}
}
}
}
int numIslands(vector<vector<char>>& grid)
{
int m = grid.size(), n = grid[0].size();
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
if(grid[i][j] == '1' && !vis[i][j])
{
ret++;
vis[i][j] = true;
bfs(grid, i, j);
}
}
}
return ret;
}
};
岛屿的最大面积
https://leetcode.cn/problems/ZL6zAn/
题目要求
题目解析
1为陆地，该题与上一题一样的做法，只不过该题需要计算最大的岛屿，只需要用一个变量统计一下每个岛屿1的数量即可
代码如下
class Solution {
public:
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int area = 0; //岛屿最大面积大小
int tmp = 0; //每个岛屿的面积大小
vector<vector<bool>> vis;
queue<pair<int, int>> q;
void bfs(vector<vector<int>>& grid, int i, int j)
{
while(q.size())
{
auto [a, b] = q.front();
q.pop();
for(int i = 0; i < 4; i++)
{
int x = a + dx[i], y = b + dy[i];
if(x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size() && grid[x][y] == 1 && !vis[x][y])
{
q.push({x, y});
tmp++;
vis[x][y] = true;
}
}
}
area = max(area, tmp);
tmp = 0;
}
int maxAreaOfIsland(vector<vector<int>>& grid)
{
int m = grid.size(), n = grid[0].size();
vis.resize(m, vector<bool>(n, false)); // 初始化访问向量
for(int i = 0; i < m; i++)
{
for(int j = 0; j < n; j++)
{
if(grid[i][j] == 1 && !vis[i][j])
{
q.push({i, j});
vis[i][j] = true;
tmp++;
bfs(grid, i, j);
}
}
}
return area;
}
};
被围绕的区域
https://leetcode.cn/problems/surrounded-regions/
题目要求
题目解析
该题的要求是将四边以外’O’区域替换成‘X’，简单地能想到遍历整个矩阵，使用一遍bfs宽度优先搜索，并且标记已经搜索过的位置，像以下这种情况就比较难判断，因为以下的区域有一部分处于边界，则不符合题意，这样的话即便遍历到‘O’，也是很难判断的
正难则反
我们可以先把包含边界上的’O’的区域处理一遍，只需调用一次bfs，将区域修改成任意符号，最后剩下的都是应该被改成’X’的区域，暴力遍历遇到’O’就修改成‘X’即可
注意最后要把包含边界的区域，重新修改为’O’（暴力遍历即可）
代码如下
class Solution {
public:
void bfs1(vector<vector<char>>& board, int i, int j)
{
queue<pair<int, int>> q;
q.push({i, j});
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
while(q.size())
{
auto [a, b] = q.front();
q.pop();
for(int k = 0; k < 4; k++)
{
int x = a + dx[k], y = b + dy[k];
if(x >= 0 && x < board.size() && y >= 0 && y < board[0].size() && board[x][y] == 'O')
{
board[x][y] = '.';
q.push({x, y});
}
}
}
}
void solve(vector<vector<char>>& board)
{
int m = board.size(), n = board[0].size();
for(int i = 0; i < n; i++)
{
if(board[0][i] == 'O')
{
board[0][i] = '.';
bfs1(board, 0, i);
}
if(board[m-1][i] == 'O')
{
board[m-1][i] = '.';
bfs1(board, m-1, i);
}
}
for(int i = 0; i < m; i++)
{
if(board[i][0] == 'O')
{
board[i][0] = '.';
bfs1(board, i, 0);
}
if(board[i][n-1] == 'O')
{
board[i][n-1] = '.';
bfs1(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'; // 捕获被围绕的 'O'
}
else if (board[i][j] == '.')
{
board[i][j] = 'O'; // 恢复已访问的 'O'
}
}
}
}
};
