【基础算法总结】BFS_FloodFill算法

24k纯甄

已于 2024-08-30 16:13:06 修改

阅读量1.7k

点赞数 125

分类专栏：经典算法专栏文章标签：算法宽度优先

于 2024-08-17 10:03:42 首次发布

本文链接：https://blog.csdn.net/2301_77900444/article/details/141269859

版权

经典算法专栏专栏收录该内容

10 篇文章 2 订阅

订阅专栏

1，算法介绍

FloodFill(洪水灌溉) 算法介绍：

假设一个 4 * 4 的方格代表一块土地，土地上有些地方是凹陷的（假设用负数表示，-1，-2，-3……大小表示凹陷程度），有些地方是凸起的（假设用正数表示，1,2,3,4……大小表示凸起程度）。

此时如果发洪水或是下雨，就会把凹陷的地方填满水，凸起的部分就会把凹陷的部分包围，填满水的区域会被连成一片一片的。

所以这类问题要么是问有多少块填平的区域，要么是问最大的区域面积是多少，要么是问某一块区域的边长是多少。

有些问题是规定只能上下左右联通，有些是斜对角也能联通。

本质就是找出具有相同性质的联通块。

解决方法：
dfs ：深度优先遍历（使用递归）
bfs：宽度优先遍历（层序遍历）

2，算法原理和代码实现(含题目链接)

733.图像渲染

在这里插入图片描述

算法原理：

使用队列进行层序遍历(bfs)。首先要记录原坐标的像素值，再以这个坐标为中心，上下左右四个方向进行遍历，如果发现有相等的像素值，就把这个坐标入队列并且修改成指定的像素值。接着再取出队头元素，进行判断，修改，遍历四个方向，入队列…直到队列为空，此时就把图中所有等于原像素值的位置修改成了指定的像素值。

细节/技巧问题：

(1) 记录完原坐标的像素值时，先进行一次判断，是否等于要修改的值，如果是，就直接返回图像。

(2) 要得到上下左右四个方向的坐标有技巧。
在这里插入图片描述

(3) 要注意遍历四个方向时坐标不能越界。

代码实现：

class Solution 
{
    typedef pair<int, int> PII;

    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
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 m = image.size();
        int n = image[0].size();

        queue<PII> q;
        q.push({sr ,sc});

        while(q.size())
        {
            auto [a, b] = q.front();
            q.pop();
            if(image[a][b] == prev) 
                image[a][b] = color;

            // 判断上下左右的值
            for(int i = 0; i < 4; i++)
            {
                int x = a + dx[i];
                int y = b + dy[i];
                if(x >=0 && x < m && y >=0 && y < n && image[x][y] == prev)
                    q.push({x, y});
            }

        }
        return image;
    }
};

200.岛屿的数量

在这里插入图片描述

算法原理：

这道题就是第一道题的进阶版，也是使用队列层序遍历(bfs)，只不过是多次使用bfs算法，所以把它写成一个函数，bfs在这里的作用是标记陆地。遍历整个矩阵，当遇到陆地(‘1’)并且没有被遍历过时，使用bfs并岛屿数量+1。

细节/技巧问题：
(1) 当取出队头坐标进行上下左右遍历时，一定会遍历到相同的位置，此时就要进行区分。可以定义一个bool类型的标记数组vis，如果位置已经遍历过，置为true，否则为false。

(2) 给bfs函数进行传参时，如果想要形参简洁一些，可以把一些变量定义在main函数外变为公有的，这样可以减少麻烦。比如这道题里矩阵的行和列，标记数组vis等

代码实现：

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

    int m,n;

    bool vis[301][301]; // 记录位置有没有被遍历过，true有,false没有
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(grid[i][j] == '1' && !vis[i][j])
                {
                    // 把这块陆地标记
                    bfs( grid,i, j);
                    ret++;
                }
            }
        }   
        return ret;
    }

    void bfs(vector<vector<char>>& grid, int i, int j)
    {
        queue<pair<int ,int>> q;
        q.push({i, j});
        vis[i][j] = true; // 入队列代表你已经遍历过了，要标记

        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 < m && y >= 0 && y < n && grid[x][y] == '1' && !vis[x][y])
                {
                    q.push({x,y});
                    vis[x][y] = true;
                }
            }
        }
    }
};

695.岛屿的最大面积

在这里插入图片描述

算法原理：

这道题也是基于前两题的bfs算法，也要多次使用bfs，所以也写成函数。它的作用是标记陆地并且统计每块陆地的面积。遍历矩阵，当遇到没有被遍历过的陆地(1)时，调用bfs函数进行标记与统计，遇到符合要求的坐标并且入队列后，陆地面积+1。统计完每一块陆地的面积再返回给main函数。

细节/技巧问题：

参考前面两题。

代码实现：

class Solution 
{
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    
    bool vis[51][51];
    int m,n;
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
         m = grid.size(), n = grid[0].size();
        int ret_max = 0;
        int ret = 0;
        for(int i = 0;i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(grid[i][j] == 1 && !vis[i][j])
                {
                    ret = bfs(grid, i, j);
                    ret_max = max(ret, ret_max);
                }
            }
        }
        return ret_max;
    }

    int bfs(vector<vector<int>>& grid, int i, int j)
    {
        int ret = 0; // 记录岛屿面积

        queue<pair<int ,int>> q;
        q.push({i, j});
        vis[i][j] = true; // 记得标记
        ret++;

        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 < m && y >= 0 && y < n && grid[x][y] == 1 && !vis[x][y])
                {
                    q.push({x, y});
                    vis[x][y] = true;
                    ret++;
                }
            }
        }
        return ret;
    }
};

130.被围绕的区域

在这里插入图片描述

算法原理：

这道题也是bfs算法的综合运用。如果按照题意正面去解决，就是直接把除与边界’O’(包括边界)联通的区域外，其余全部修改为’X’，会显的很麻烦。所以正难则反，我们可以先把与边界’O’(包括边界)联通的区域修改为其他字符，再遍历整个数组，把剩余的’O’区域修改为’X’，最后把原来修改为的其他字符还原为’O’，这样也可以解决问题，并且整个代码书写也更清晰。当然，这里的bfs算法也不止使用一次，所以也要写成函数，它的作用是把与边界’O’(包括边界)联通的区域修改为其他字符。

细节/技巧问题：

参考前面三题

代码实现：

class Solution 
{
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    int m, n;
    bool vis[201][201];
public:
    void solve(vector<vector<char>>& board) 
    {
        m = board.size(), n = board[0].size();
        // 先把边界上的'O'区域改为无关字符
        for(int i = 0; i < m; i++)
        {
            if(board[i][0] == 'O') bfs(board, i, 0);
            if(board[i][n-1] == 'O') bfs(board, i, n-1);
        }
        for(int j = 0; j < n; j++)
        {
            if(board[0][j] == 'O') bfs(board, 0, j);
            if(board[m-1][j] == 'O') bfs(board, m-1, j);
        }
        // 再遍历矩阵，把所有'O'改为'X'
        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';
            }
        }
        // 最后还要把前面改过的'.'还原为'O'
        for(int i = 0; i< m; i++)
        {
            for(int j = 0; j < n; j++)
                if(board[i][j] == '.')
                    board[i][j] = 'O';
        }
    }

    void bfs(vector<vector<char>>& board, int i, int j)
    {
        queue<pair<int ,int>> q;
        q.push({i ,j});
        vis[i][j] = true;
        board[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 < m && y >= 0 && y < n && !vis[x][y] && board[x][y] == 'O')
                {
                    q.push({x, y});
                    vis[x][y] = true;
                    board[x][y] = '.';
                }
            }
        }
    }
};