【4.3】图搜索算法-DFS和BFS解被围绕的区域

一、题目

        给定一个二维的矩阵，包含 ' 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'。如果两个元素在水平 或垂直方向相邻，则称它们是“相连”的。

二、解题思路

DFS方式解决：

        题目要求我们将被X包围的O区域替换为X。为了判断O是否被X包围，我们可以采用一种间接的方法。假设矩阵的四周都是X，那么矩阵中任何O必定是被X包围的。如下

        如果矩阵的四周只要有一个是O，那么和这个O直接相邻（仅指上下左右，斜对角不算）的O都不可能被X包围。如下

        因此，一种较为简便的判断方法是检查矩阵的四周是否存在O。若存在O，则表明该O及其直接相邻的O（仅限上下左右，不包括斜对角）无法被X包围，因此不能被替换为X。我们可以先将这些O标记为大写的A（或其他非X和O的字符），然后继续检查其上下左右是否有O，若有，同样标记为A。

最终，矩阵中可能出现三种状态：X、A和O。
- 对于X，保持不变。
- 对于O，说明它们是被X包围的，需要将其替换为X。
- 对于A，说明它们无法被X包围，需将其还原为O。

BFS方式解决：

        DFS是沿着一个方向一直走下去，BFS是先遍历四周的，然后再往外扩散，如下图所示

        原理还是一样的，从矩阵的四周开始，找到一个O之后，把它变为A，然后把他的四周在

遍历一遍，如果有O就加入到队列中，然后继续遍历队列中的元素。

三、代码实现

DFS实现代码：

#include <iostream>
#include <vector>

using namespace std;

void dfs(int i, int j, vector<vector<char>>& board) {
    // 边界条件判断，首先不能跑到矩阵的外边
    if (i < 0 || i >= board.size() || j < 0 || j >= board[0].size())
        return;
    // 如果当前位置不是O，就不用再判断了
    if (board[i][j] != 'O')
        return;
    // 如果当前位置是O，先把他变为'A'，然后往他的上下左右4个方向开始递归计算。
    board[i][j] = 'A';
    dfs(i - 1, j, board); // 上
    dfs(i + 1, j, board); // 下
    dfs(i, j - 1, board); // 左
    dfs(i, j + 1, board); // 右
}

void solve(vector<vector<char>>& board) {
    // 边界条件判断
    if (board.empty() || board[0].empty())
        return;

    int rows = board.size();
    int cols = board[0].size();

    // 从矩阵的四周开始判断，也就是矩阵的4条边上有O的地方开始遍历
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (i == 0 || i == rows - 1 || j == 0 || j == cols - 1) {
                if (board[i][j] == 'O')
                    dfs(i, j, board);
            }
        }
    }

    // 重新复原
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            // 把矩阵中是'A'的还变为O，其他的都变成X
            if (board[i][j] == 'A')
                board[i][j] = 'O';
            else
                board[i][j] = 'X';
        }
    }
}

int main() {
    vector<vector<char>> board = {
        {'X', 'X', 'X', 'X'},
        {'X', 'O', 'O', 'X'},
        {'X', 'X', 'O', 'X'},
        {'X', 'O', 'X', 'X'}
    };

    solve(board);

    // 输出结果
    for (const auto& row : board) {
        for (char c : row) {
            cout << c << " ";
        }
        cout << endl;
    }

    return 0;
}

BFS实现代码：

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

void bfs(int i, int j, vector<vector<char>>& board) {
    queue<int> queue;
    // 把当前位置变为A
    board[i][j] = 'A';
    // 把当前的坐标加入到队列中
    queue.push(i);
    queue.push(j);

    vector<vector<int>> direction = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};

    while (!queue.empty()) {
        // 坐标出队
        int queueI = queue.front(); queue.pop();
        int queueJ = queue.front(); queue.pop();

        // 沿着当前位置(queueI,queueJ)的上下左右四个方向查找
        for (int k = 0; k < 4; k++) {
            int x = direction[k][0] + queueI;
            int y = direction[k][1] + queueJ;

            // 边界条件判断，首先不能跑到矩阵的外边
            if (x < 0 || x >= board.size() || y < 0 || y >= board[0].size())
                continue;

            // 如果当前位置不是O，就不用再判断了
            if (board[x][y] != 'O')
                continue;

            // 否则就把他变为A
            board[x][y] = 'A';

            // 然后再把这个位置的坐标存放到队列中
            queue.push(x);
            queue.push(y);
        }
    }
}

void solve(vector<vector<char>>& board) {
    // 边界条件判断
    if (board.empty() || board[0].empty())
        return;

    int rows = board.size();
    int columns = board[0].size();

    // 从矩阵的四周开始判断，也就是矩阵的4条边上有O的地方开始遍历
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            if (i == 0 || i == rows - 1 || j == 0 || j == columns - 1) {
                if (board[i][j] == 'O')
                    bfs(i, j, board);
            }
        }
    }

    // 重新复原
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            // 把矩阵中是'A'的还变为O，其他的都变成X
            if (board[i][j] == 'A')
                board[i][j] = 'O';
            else
                board[i][j] = 'X';
        }
    }
}

int main() {
    vector<vector<char>> board = {
        {'X', 'X', 'X', 'X'},
        {'X', 'O', 'O', 'X'},
        {'X', 'X', 'O', 'X'},
        {'X', 'O', 'X', 'X'}
    };

    solve(board);

    // 输出结果
    for (const auto& row : board) {
        for (char c : row) {
            cout << c << " ";
        }
        cout << endl;
    }

    return 0;
}

        为了找到被X包围的区域，最简单的方法是从矩阵的四周开始查找。如果四周存在O，那么这些O及其直接相邻的O（仅限上下左右，不包括斜对角）必定无法被X包围。我们可以先将这些O标记为大写的A（或其他非X和O的字符），然后继续检查其相邻的O，同样标记为A。最终，剩下的未被标记为A的O必定是被X包围的。