目录
一、算法简介
FloodeFill算法即填充算法，原理就是从一个点开始向四周扩散，向周围可以走到的点填充颜色，直到将可扩散到的点全部填充颜色。
通常使用下面两种方法解决FloodFill算法问题：
- BFS （宽搜）算法通常使用队列实现，将起始像素点加入队列中，并不断扩展队列中的像素点，直到队列为空为止。
- DFS（深搜） 算法通常使用递归实现，在处理当前像素点的相邻像素点时，递归调用 DFS 函数，不断深入直到无法找到相邻像素为止。
假设这一块4*4的方格是一块土地，有凸起的地方，也有凹陷的地方（凹陷的地方用负数表示）。此时下大雨发洪水，会把凹陷的地方填满。绿色圈起来的属于一块区域（上下左右四个方向，有时候题目也会问八个方向包括斜着相连的），题目会问有多少块区域被填满，或者问被填满的最大区域是哪个，或某一块区域的边长是多少。但是本质都是在一块区域找性质相同的连通块。
- DFS：深度优先遍历（递归）：从某一点开始一条路走到黑。以最右列的为例，从-1出发，向下->-2->-10->-12，此时发现-12的上下左右都走不了，在拐回去到-10，然后发现-10左边可以走->-4->-3。
- BFS：宽度优先遍历：一层一层拨开。还是以最右边为例，从-1开始拓展一层（上下左右）发现能把-2扩展出来，接着继续扩展一层上下左右，-3和-10扩展出来；接着在扩展一层上下左右，把-4和-12扩展出来。
int dx[4] = {0, 0 , -1, 1};
int dy[4] = {1, -1 , 0, 0};
// i点加dx，dy就是i点的上下左右的下标 二、相关例题
1）图像渲染
.1- 题目解析
利用深搜 DFS，遍历到与该点相连的所有像素相同的点，然后将其修改成指定的像素即可。
.2- 代码编写
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）岛屿数量
.1- 题目解析
遍历整个矩阵，每次找到一块陆地，也就是找到了一个岛屿，并用一个变量 ret 来对岛屿数量计数。
特别的，遇到一块岛屿就将它全部变成海洋，这样的话，下次遍历到这块岛屿的时候，它已经是海洋了，不会影响最终结果，其中变成海洋的操作，可以利用 DFS 解决。
.2- 代码编写
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++;
vis[i][j] = true;
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) {
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') {
vis[x][y] = true;
dfs(grid, x, y);
}
}
}
};3）岛屿的最大面积
.1- 题目解析
遍历整个矩阵，每当遇到一块土地的时候，就用 DFS 将与这块土地相连的整个岛屿的面积计算出来,然后在搜索得到的所有的岛屿面积求一个最大值即可。在搜索过程中，为了防止搜到重复的土地，可以开一个同等规模的 bool 数组，标记一下这个位置是否已经被访问过。
.2- 代码编写
class Solution {
bool vis[51][51];
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int m,n;
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）被围绕的区域
.1- 题目解析
正难则反。
可以先利用 DFS 将与边缘相连的 'O' 区域修改成无关字符，然后重新遍历矩阵，将没有标记过的 'O' 全修改成 'X' 即可，再把无关字符全还原成'O'。
.2- 代码编写
class Solution {
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int m,n;
public:
void solve(vector<vector<char>>& board) {
m=board.size(),n=board[0].size();
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);
}
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）太平洋大西洋水流问题
.1- 题目解析
题目要求返回既可以流向太平洋、又可以流向大西洋的单元格坐标。
如果直接去判断某一个位置是否既能到大西洋也能到太平洋，会重复遍历很多路径。那么我们就可以正难则反，从大西洋沿岸开始反向 DFS，这样就能找出哪些点可以流向大西洋；同理，从太平洋沿岸也反向 DFS ，这样就能找出那些点可以流向太平洋，而被标记两次的点，就是要找的结果。
.2- 代码编写
class Solution {
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int m,n;
public:
vector<vector<int>> pacificAtlantic(vector<vector<int>>& h) {
m=h.size(),n=h[0].size();
vector<vector<bool>> pac(m,vector<bool>(n));//标识可以流向太平洋
vector<vector<bool>> atl(m,vector<bool>(n));//标识可以流向大西洋
//处理太平洋
for(int j=0;j<n;j++)dfs(h,0,j,pac);
for(int i=0;i<m;i++)dfs(h,i,0,pac);
//处理大西洋
for(int i=0;i<m;i++)dfs(h,i,n-1,atl);
for(int j=0;j<n;j++)dfs(h,m-1,j,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>>& h,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] && h[x][y]>=h[i][j])
{
dfs(h,x,y,vis);
}
}
}
};6）扫雷游戏
.1- 题目解析
从题目所给的点击位置开始，根据游戏规则，来一次 DFS 即可。DFS 的大致步骤，就是统计一下周围的地雷个数，有地雷就在当前位置放上周围地雷的个数，然后返回，没有地雷就改当前位置为没有地雷的空白块 B，然后 DFS 周围的未挖出的空方块 E。
.2- 代码编写
class Solution {
int dx[8] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[8] = {0, 0, 1, -1, -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;
//周围没有地雷只有空方格，继续dfs周围的方格
} 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）衣橱整理
.1- 题目解析
可以通过深搜或者宽搜，从 [0, 0] 点出发，按照题目的规则一直往 [m - 1, n - 1] 位置走。 同时设置一个全局变量。每次走到一个合法位置，就将全局变量加一。当我们把所有能走到的路都走完之后，全局变量里面存的就是最终答案。
.2- 代码编写
class Solution {
int m,n,k;
bool vis[101][101];
int ret;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
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<4;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;
}
};
扫一扫
2036
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
