leetcode 130.被包围的区域

leetcode 130.被包围的区域

给定一个二维的矩阵,包含 ‘X’ 和 ‘O’(字母 O)。

找到所有被 ‘X’ 围绕的区域,并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例:

X X X X
X O O X
X X O X
X O X X
运行你的函数后,矩阵变为:

X X X X
X X X X
X X X X
X O X X
解释:

被围绕的区间不会存在于边界上,换句话说,任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上,或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻,则称它们是“相连”的。

题解

注意点:
* 防御性编程,vector为空时要记得return,而且读取列数的操作一定要放在return后,否则可能出现空指异常
* 函数传入参数时参数的对应

class Solution {
    
    
public:
    int n,m;
    void dfs(vector<vector<char>>& board,int x,int y){
    
    
        if(x<0||x>=n||y<0||y>=m||board[x][y]!='O')
            return;
        board[x][y] = 'A';
        dfs(board,x,y-1);//**不管三七二十一总之先把相邻的所有坐标dfs再说**
        dfs(board,x,y+1);
        dfs(board,x-1,y);
        dfs(board,x+1,y);
    }

    void solve(vector<vector<char>>& board) {
    
    //从边界开始dfs,使所有与边界O相邻的O标记为A
        n = board.size();//行数
        if(n==0)
            return;
        m = board[0].size();//列数
        for(int i=0;i<m;i++)
        {
    
    
            dfs(board,0,i);
            dfs(board,n-1,i);
        }
        for(int i=1;i<n-1;i++)
        {
    
    
            dfs(board,i,0);
            dfs(board,i,m-1);
        }
        for(int i=0;i<n;i++)
        {
    
    
            for(int j=0;j<m;j++)
            {
    
    
                if(board[i][j]=='A')
                    board[i][j] = 'O';
                else if(board[i][j]=='O')
                    board[i][j] = 'X';
            }
        }
        
    }
};

bfs题解

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

    void solve(vector<vector<char>>& board) {
    
    
        int n = board.size();//获取矩阵的行数
        if (n == 0) {
    
    
            return;
        }
        int m = board[0].size();//获取矩阵的列数
        queue<pair<int, int>> que;
        for (int i = 0; i < n; i++) {
    
    //遍历矩阵第一列与末列
            if (board[i][0] == 'O') {
    
    
                que.emplace(i, 0);//emplace在queue末尾插入一个数据,此处推入第一列为O的坐标
            }
            if (board[i][m - 1] == 'O') {
    
    //对末列的操作
                que.emplace(i, m - 1);
            }
        }
        for (int i = 1; i < m - 1; i++) {
    
    //遍历矩阵首行和末行
            if (board[0][i] == 'O') {
    
    
                que.emplace(0, i);   //推入首行为O的坐标
            }
            if (board[n - 1][i] == 'O') {
    
    
                que.emplace(n - 1, i);//推入末行为O的坐标
            }
        }
        while (!que.empty()) {
    
    
            int x = que.front().first, y = que.front().second;//把队列que中首元素的pair储存的坐标读入到x y中,x表示第几行,y表示第几列
            que.pop();//把已读入的元素抛出
            board[x][y] = 'A';//将获得的坐标标记A
            for (int i = 0; i < 4; i++) {
    
    //通过i0-3来实现相邻四个坐标的遍历,见public后const声明
                int mx = x + dx[i], my = y + dy[i];//通过mx和my来储存相邻坐标
                if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != 'O') {
    
    
                    continue;//**若相邻的标记不为O或者超界则不推入新坐标继续遍历下一个相邻坐标,不会无脑推入所有相邻坐标**
                }
                que.emplace(mx, my);//若相邻的标记为O则推入相邻坐标
            }
        }
        for (int i = 0; i < n; i++) {
    
    //遍历矩阵全部元素,将标记为A的还原为O,标记仍然为O的变为X
            for (int j = 0; j < m; j++) {
    
    
                if (board[i][j] == 'A') {
    
    
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
    
    
                    board[i][j] = 'X';
                }
            }
        }
    }
};

猜你喜欢

转载自blog.csdn.net/weixin_43662405/article/details/108674045
今日推荐