Flood Fill问题详情(BFS)

原创已于 2024-05-29 18:08:50 修改 · 1.1k 阅读

18 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#宽度优先 #算法 #c语言 #数据结构 #leetcode

于 2024-05-29 18:04:02 首次发布

Flood Fill

概念

Flood Fill翻译过来就是洪水覆盖，意思就是从一个点开始找它的连通集。

比如说有这么一个矩阵只包含数字0和1，如果说从左上角的数字开始找，那么应该找到的是这个样子的。也就是说找到上下左右(一般是指上下左右四个方向，也有可能包含对角)与开始相同的一个区域.

1 1 0 0 0 1 1 0 0 0

0 1 1 0 0 0 1 1 0 0

1 0 1 0 0 1 0 1 0 0

处理方式

遇到这种情况我们一般采用DFS或者BFS，这里只介绍BFS，DFS是指从一条路一直走下去，直到走不通再回去，而BFS是一层一层的走，直到走完就结束了。还是以上面的矩阵为例。

第一层我们就将初始点放进去用，红色来标记第一层。

1 1 1 0 0

0 1 1 0 0

1 0 1 0 0

第二层就找第一层的上下左右相等的集合，用蓝色标记第二层

1 1 1 0 0

0 1 1 0 0

1 0 1 0 0

第三层同理，黄色标记

1 1 1 0 0

0 1 1 0 0

1 0 1 0 0

第四层

1 1 1 0 0

0 1 1 0 0

1 0 1 0 0

第五层，找不到结束

1 1 1 0 0

0 1 1 0 0

1 0 1 0 0

一层一层的走可以用队列的先进先出来得到很好的解决，将队列的首元素拿出来，用首元素的上下左右找符合条件的，然后符合条件的再入队列就可以了。

但是这里值得注意的是，我们需要将走过的位置标记一下，因为如果不标记的话，我们往下走的话，依然会回去，这样就会造成死循环了，这里一般有两种解决方案。

第一种:每走一个元素就用一个其它的数字或字符来修改原来的矩阵，但是这样有一个不好的地方，那就是会修改原来矩阵，就会稍微麻烦一些。

第二种:这一种也是最常用的一种，就是再取一个相同大小的矩阵全部初始化0，意味着还没有走，如果每走一个元素，就把他对应的新矩阵的位置改成1，就代表走过了。

小技巧

每一层走的时候需要判断上下左右四个方向，对于判断方向，我们可以做这样的处理。

int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};

dx和dy代表起始位置的变化量，如下所示。

                y
              (x-1,y)
x    (x,y-1)  (x,y)    (x,y+1)
              (x+1,y)

也就是说每次只让加上对应的dx，dy就可以找到上下左右了。

例题

733. 图像渲染 - 力扣（LeetCode）

题意

简单来说就是给一个矩阵和一对点还有一个值，将从这个点所构成的连通集都变成新给的值。

题解

这一道题是对原数组进行更改的，所以用上面的第一种方案就可以了。

首先处理边界情况，这里的边界情况就是给的点的值和给的color的值一样时，直接返回矩阵即可。

接着我们需要一个值做标记，标记我们需要找的元素，接着创建一个队列，将给的点入到队列里，入一对点的时候我们可以用pair<>，入进去之后，再将那对点的值换成color即可。

        int dst = image[sr][sc],n = image.size(),m = image[0].size();
        if(dst==color) return image;
        queue<pair<int,int>> q;
        q.push({sr,sc});
        image[sr][sc] = color;

接着就是一层一层的出入了，可以用while循环，条件是这个队列不为空，循环体我们要做的操作就是取队头元素，删队头元素，判断队头元素的上下左右，满足条件首先改color，然后再入队列。

        while(!q.empty())
        {
            auto [x,y] = q.front();//取队头元素
            q.pop();//出对头元素
            for(int i = 0;i<4;i++)//上下左右四个方向
            {
                int xi = x + dx[i],yi = y + dy[i];
                if(xi>=0&&xi<n&&yi>=0&&yi<m&&image[xi][yi]==dst)//是否是连通集
                {
                    q.push({xi,yi});
                    image[xi][yi] = color;
                }
            }
        }

将这两部分合并就是完整代码了。

200. 岛屿数量 - 力扣（LeetCode）

题意

这一道题就是找矩阵中共有多少个为'1'的连通集，方向仍然是上下左右，如图所示，共有三个为1的连通集。

题解

与上一道题不同是，这一道题我们需要遍历一遍这个矩阵来找所有可能出现1的地方，并且也不用对原数组进行修改，而是用一个check数组来做检查，如果该区域已经找过了，那就不需要再找了，所以大致过程和上一道题是差不多的。

代码

class Solution
{
    int check[301][301] = {0};//用于检查是否找过
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
public:

    void bfs(const vector<vector<char>>& grid,int x,int y)
    {
        int n = grid.size(),m = grid[0].size();
        queue<pair<int,int>> q;
        q.push({x,y});//将第一个元素入队
        check[x][y] = 1;//将这个元素对应的位置标记为走过
        while(!q.empty())
        {
            auto [a,b] = q.front();//取队头元素
            q.pop();//出队头
            for(int i = 0;i<4;i++)//上下左右四个方向
            {
                int xi = a + dx[i],yi = b + dy[i];
                if(xi>=0&&xi<n&&yi>=0&&yi<m&&grid[xi][yi]-'0'==1&&check[xi][yi]==0)//判断是否可以走
                {               
                    q.push({xi,yi});//入队
                    check[xi][yi] = 1;//标记
                }
            
            }
            
        }
    }

    int numIslands(vector<vector<char>>& grid)
    {
        int ret = 0,n = grid.size(),m = grid[0].size();
        for(int i = 0;i<n;i++)
        {
            for(int j = 0;j<m;j++)
            {
                if(grid[i][j]-'0'==1&&check[i][j]==0)//判断是否是第一次检查这个区域
                {
                    bfs(grid,i,j);
                    ret++;
                }
            }
        }
        return ret;
    }
};

LCR 105. 岛屿的最大面积 - 力扣（LeetCode）

题意

找所有为1的连通集面积的最大值。

题解

和上一道题基本一致，上一道是找所有的连通集的个数，这个是找连通集的最大面积，稍作更改即可。

代码

class Solution
{
    int check[51][51] = {0};//用来检查
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
public:

    int bfs(const vector<vector<int>>& grid,int x,int y)
    {
        int n = grid.size(),m = grid[0].size();
        queue<pair<int,int>> q;
        q.push({x,y});//入队
        check[x][y] = 1;//标记
        int ret = 0;//计数
        while(!q.empty())
        {
            auto [a,b] = q.front();//取队头
            q.pop();//出队头
            for(int i = 0;i<4;i++)//上下左右
            {
                int xi = a + dx[i],yi =  b + dy[i];
                if(xi>=0&&xi<n&&yi>=0&&yi<m&&grid[xi][yi]==1&&check[xi][yi]==0)//判断
                {
                    q.push({xi,yi});//入队
                    check[xi][yi] = 1;//标记
                }
            }
            ret++;//计数
        }
        return ret;
    }

    int maxAreaOfIsland(vector<vector<int>>& grid)
    {
        int ret = 0,n = grid.size(),m = grid[0].size();
        for(int i = 0;i<n;i++)
        {
            for(int j = 0;j<m;j++)
            {
                if(grid[i][j]==1&&check[i][j]==0)//判断是否第一次找到这个连通集
                ret = max(ret,bfs(grid,i,j));//更新
            }
        }
        return ret;
    }
};

130. 被围绕的区域 - 力扣（LeetCode）

题意

这一道题是找将X所围绕的O全部变成X，如果没被X包围就不用变。

题解

思路一

暴力一点的就是和上面一样去找O的连通集，如果这个连通集到墙边了，那么这个连通集就不需要更改，如果没到墙边也就是被X包围就需要改成X，这样的话我们就需要用两次bfs了，第一次是看是否到墙边，第二次是如果到了不做处理，如果没到就需要将这个连通集做更改，有点麻烦诶。

思路二

所谓正难则反，我们可以之间去最外围一周去找O的连通集，将O改成一个别的字符，然后在遍历一次这个矩阵，将改成的别的字符换成O，然后把O换成X。

代码

class Solution
{
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
public:
    
    void bfs(vector<vector<char>>& board,int x,int y)
    {
        int n = board.size(),m = board[0].size();
        queue<pair<int,int>> q;
        q.push({x,y});//入队
        board[x][y] = '1';//更改
        while(!q.empty())
        {
            auto [a,b] = q.front();//入队
            q.pop();//出队
            for(int i = 0;i<4;i++)//上下左右
            {
                int xi = a + dx[i],yi =  b + dy[i];
                if(xi>=0&&xi<n&&yi>=0&&yi<m&&board[xi][yi]=='O')//判断
                {
                    q.push({xi,yi});//入队
                    board[xi][yi] = '1';//更改
                }
            }
        }
    }

    void solve(vector<vector<char>>& board)
    {
        int n = board.size(),m = board[0].size();
        for(int j = 0;j<m;j++)//四周
        {
            if(board[0][j]=='O') bfs(board,0,j);
        }
        for(int j = 0;j<m;j++)//四周
        {
            if(board[n-1][j]=='O') bfs(board,n-1,j);
        }
        for(int i = 0;i<n;i++)//四周
        {
            if(board[i][0]=='O') bfs(board,i,0);
        }
        for(int i = 0;i<n;i++)四周
        {
            if(board[i][m-1]=='O') bfs(board,i,m-1);
        }
        for(int i = 0;i<n;i++)//遍历
        {
            for(int j = 0;j<m;j++)
            {
                if(board[i][j]=='1') board[i][j]='O';//替换
                else if(board[i][j]=='O') board[i][j]='X';//替换
            }
        }
    }
};