一、题目
给定一个二维的矩阵，包含 ' 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包围的。
