算法_宽度优先搜索解决FloodFill---持续更新

前言

本文将会向你介绍宽度优先搜索解决FloodFill算法相关题型：图像渲染、岛屿数量、岛屿的最大面积、被围绕的区域

什么是FloodFill算法

FloodFill算法是一种用于图像处理和计算机图形学的算法，主要用于填充一个区域的颜色。它的基本思想是从一个起始点开始，检查该点的颜色，并将其替换为新的颜色，然后递归地检查相邻的像素（通常是上下左右四个方向），如果相邻的像素颜色与起始点的颜色相同，则继续填充。

图像渲染

https://leetcode.cn/problems/flood-fill/

题目要求

题目解析

题目要求将指定点周围（上下左右）同色（数字相同）的点改为指定的值（上色），接着再记录与刚上色的点上下左右同色的新的点，重复该过程…
这种有点像是内层一圈一圈向外发散的感觉
这里还是利用队列进行层序遍历，前面也有介绍过这种方法https://blog.youkuaiyun.com/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'  
                }  
            }  
        }  
    }
};