优先算法专题十五——BFS_FloodFill

泛洪覆盖式地一层一层向外扩展

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

可将pair<int, int> 重命名为PII，方便代码编写

dx, dy加上当前坐标可计算当前位置的上下左右下标

提前记录image[sr][sc]的颜色，方便层次遍历时比较

class Solution {
public:
    typedef pair<int, int> PII;
    vector<int> dx = {0, 0, -1, 1};
    vector<int> dy = {-1, 1, 0, 0};
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {
        if(image[sr][sc] == color)
            return image;
        int l = image.size(), r = image[0].size();
        queue<PII> q;
        q.push({sr, sc});
        int basis_color = image[sr][sc];
        while(!q.empty())
        {
            PII p = q.front();
            q.pop();
            image[p.first][p.second] = color;
            for(int i = 0; i < 4; i++)
            {
                int x = p.first + dx[i], y = p.second + dy[i];
                if(x >=0 && x < l && y >= 0 && y < r && image[x][y] == basis_color)
                    q.push({x, y});
            }
        }
        return image;
    }
};

//思路：层次遍历，每次删除队列中元素之后进入这个元素周围上下左右和其值相同的元素，重复此操作

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

两层for循环遍历数组grid，若是这个位置为1并且未被访问就让ans++，并且进入dfs函数使用层次遍历将这个位置以及相连陆地全部标记为访问过的；下一次两层for循环找到的1就一定是未发现的岛屿，ans++。

class Solution {
public:
    vector<int> dx = {0, 0, -1, 1};
    vector<int> dy = {-1, 1, 0, 0};
    int l, r;

    int numIslands(vector<vector<char>>& grid) {
        l = grid.size(), r = grid[0].size();
        //防止修改原数组，新建一个数组来表示这个位置是否被访问过
        vector<vector<bool>> vis(l, vector<bool>(r, false));
        int ans = 0;
        for(int i = 0; i < l; i++)
        {
            for(int j = 0; j < r; j++)
            {
                if(!vis[i][j] && grid[i][j] == '1')
                {
                    ans++;
                    dfs(vis, grid, i, j);//在这里面将这个(i, j)相连陆地全部标记成访问过的
                }
            }
        }
        return ans;
    }
    void dfs(vector<vector<bool>>& vis, vector<vector<char>>& grid, int i, int j)
    {
        queue<pair<int, int>> q;
        q.push({i, j});
        vis[i][j] = true;
        while(!q.empty())
        {
            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 < l && y >=0 && y < r && !vis[x][y] && grid[x][y] == '1')
                {
                    q.push({x, y});
                    vis[x][y] = true;
                }
            }
        }
    }
};

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

class Solution {
public:
    vector<int> dx = {0, 0, 1, -1};
    vector<int> dy = {1, -1, 0, 0};
    //bool vis[50][50] = {false};
    vector<vector<bool>> vis = {50, vector<bool>(50, false)};   

    int n = 0;
    int m = 0;

    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
        n = grid.size(); 
        m = grid[0].size();
        int ans = 0;

        for(int i = 0; i < n; i++)
            for(int j = 0; j < m; j++)
                if(vis[i][j] == false && grid[i][j] == 1)
                    ans = max(ans, bfs(i, j, grid));
        return ans;
    }
    int bfs(int i, int j, vector<vector<int>>& grid)
    {
        int count = 0;
        queue<pair<int, int>> myq;

        myq.push({i, j});
        ++count;
        vis[i][j] = true;

        while(!myq.empty())
        {
            auto [a, b] = myq.front();
            myq.pop();

            for(int k = 0; k < 4; k++)
            {
                int x = a + dx[k];
                int y = b + dy[k];
                if(x >= 0 && x < n && y >= 0 && y < m && vis[x][y] == false && grid[x][y] == 1)
                {
                    myq.push({x, y});
                    ++count;
                    vis[x][y] = true;
                }
            }
        }
        return count; 
    }
};

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

//正着来，直接做
// class Solution {
// public:
//     int n = 0, m = 0;
//     vector<int> dx = {0, 0, 1, -1};
//     vector<int> dy = {1, -1, 0, 0};
//     vector<vector<bool>> vis = {201, vector<bool>(201, false)};
//     void solve(vector<vector<char>>& board) 
//     {
//         n = board.size();
//         m = board[0].size();

//         for(int i = 0; i < n; i++)
//         {
//             for(int j = 0; j < m; j++)
//             {
//                 if(board[i][j] == 'O' && vis[i][j] == false)
//                 {
//                     bfs(board, i, j);
//                 }
//             }
//         }
//     }

//     //要判断这个区域是否和边界相连
//     void bfs(vector<vector<char>>& board, int i, int j)
//     {
//         //一个队列进行bfs遍历，另一个队列进行记录'O'下标
//         queue<pair<int, int>> q1, q2;
//         q1.push({i, j});
//         q2.push({i, j});
//         vis[i][j] = true;
//         while(q1.size())
//         {
//             auto [a, b] = q1.front();
//             q1.pop();
//             for(int k = 0; k < 4; k++)
//             {
//                 int x = a + dx[k];
//                 int y = b + dy[k];
//                 if(x >= 0 && x < n && y >= 0 && y < m && board[x][y] == 'O' && vis[x][y] == false)
//                 {
//                     q1.push({x, y});
//                     q2.push({x, y});
//                     vis[x][y] = true;
//                 }
//             }
//         }
//         //判断'O'区域有没有和边界相连，有则无法包围，返回即可；无则全部变为'X'
//         //由于vis的标记，下一次也不会再访问这个'O'区域的任何位置
//         queue<pair<int, int>> q3 = q2;
//         int flag = 1;
//         while(q2.size())
//         {
//             auto [a, b] = q2.front();
//             q2.pop();
//             if(a == 0 || a == n - 1 || b == 0 || b == m - 1)
//             {
//                 flag = 0;
//                 break;
//             }
//         }
//         if(flag)
//         {
//             while(q3.size())
//             {
//                 auto [a, b] = q3.front();
//                 board[a][b] = 'X';
//                 q3.pop();
//             }
//         }
//         else return;
//     }
// };


//反着来
//先遍历一遍矩形的边界，碰见'O'，则对其进行bfs，做标记（改成'*'），表示和边界相连的'O'区域不用再管了
//层次遍历结束，遍历一遍矩阵，碰见'O'就换成'X'（此时绝对被包围）；碰见'*'还原成'O'即可
class Solution {
public:
    int n = 0, m = 0;
    vector<int> dx = {0, 0, 1, -1};
    vector<int> dy = {1, -1, 0, 0};
    void solve(vector<vector<char>>& board) 
    {
        n = board.size();
        m = board[0].size();
        for(int i = 0, j = 0; j < m; j++)
        {
            if(board[i][j] == 'O')
                bfs(board, i, j);
        }
        for(int i = n - 1, j = 0; j < m; j++)
        {
            if(board[i][j] == 'O')
                bfs(board, i, j);
        }
        for(int i = 0, j = 0; i < n; i++)
        {
            if(board[i][j] == 'O')
                bfs(board, i, j);
        }
        for(int i = 0, j = m - 1; i < n; i++)
        {
            if(board[i][j] == 'O')
                bfs(board, i, j);
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                if(board[i][j] == 'O')
                    board[i][j] = 'X';
                else if(board[i][j] == '*')
                    board[i][j] = 'O';
            }
        }
    }
    void bfs(vector<vector<char>>& board, int i, int j)
    {
        queue<pair<int, int>> q1;
        q1.push({i, j});
        board[i][j] = '*';
        while(q1.size())
        {
            auto [a, b] = q1.front();
            q1.pop();
            for(int k = 0; k < 4; k++)
            {
                int x = a + dx[k];
                int y = b + dy[k];
                if(x >= 0 && x < n && y >= 0 && y < m && board[x][y] == 'O')
                {
                    q1.push({x, y});
                    board[x][y] = '*';
                }
            }
        }
    }
};