Leetcode-搜索-130.被围绕的区域(中等)

题目如下

解题思路

不被包围的肯定有一边在边界，所以我们从边界遍历，边界遍历可以碰到的0是不会被改变的，里面遍历不到的说明肯定被包围了
1.深度优先搜索，就是深搜，从边界往四个方向递归
2.广度优先搜索，就是广搜，边界遇到0了先压到队列里面，之后从队列里面来进行判断

dfs-c++代码(深搜)

class Solution {
public:
    int n;
    int m;
    void dfs(vector<vector<char>>& board, int x, int y)
    {   //返回条件，越界，或者是X或者#
        if(x<0 || x>=n || y<0 || y>=m || board[x][y] != 'O'){
            return;
        }
        board[x][y] = '#';//标记
        dfs(board,x+1,y);//右
        dfs(board,x,y+1);//上
        dfs(board,x-1,y);//左
        dfs(board,x,y-1);//下
    }
    void solve(vector<vector<char>>& board) {   //找到被围起来的o变成x，和边界相连的O就是不用变的        
        n = board.size();//行数
        if(n == 0)return;//空的
        m = board[0].size();//列数
        for(int i=0;i<n;i++){
            dfs(board,i,0);//第一列
            dfs(board,i,m-1);//最后一列
        }
        for(int i=0;i<m;i++){
            dfs(board,0,i);//第一行
            dfs(board,n-1,i);//最后一行
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(board[i][j] == '#'){
                    board[i][j] = 'O';
                }
                else if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
            }
        }
    }
};

bfs-c++代码(广搜)

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);
            }
            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);   
            }
            if (board[n - 1][i] == 'O') {
                que.emplace(n - 1, i);
            }
        }
        while (!que.empty()) {
            int x = que.front().first, y = que.front().second;
            que.pop();
            board[x][y] = 'A';
            for (int i = 0; i < 4; i++) {
                int mx = x + dx[i], my = y + dy[i];
                if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != 'O') {
                    continue;
                }
                que.emplace(mx, my);
            }
        }
        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(广度搜索更快，但是内存消耗更多)
dfs(深度搜索内存消耗更少，但是相对慢些)
这就是以时间换空间，以空间换时间！