Every day a Leetcode
题目来源：130. 被围绕的区域
本题给定的矩阵中有三种元素：
- 字母 X；
- 被字母 X 包围的字母 O；
- 没有被字母 X 包围的字母 O。
本题要求将所有被字母 X 包围的字母 O都变为字母 X ，但很难判断哪些 O 是被包围的，哪些 O 不是被包围的。
注意到题目解释中提到：任何边界上的 O 都不会被填充为 X。 我们可以想到，所有的不被包围的 O 都直接或间接与边界上的 O 相连。
我们可以利用这个性质判断 O 是否在边界上，具体地说：
对于每一个边界上的 O，我们以它为起点，标记所有与它直接或间接相连的字母 O；
最后我们遍历这个矩阵，对于每一个字母：
- 如果该字母被标记过，则该字母为没有被字母 X 包围的字母 O，我们将其还原为字母 O；
- 如果该字母没有被标记过，则该字母为被字母 X 包围的字母 O，我们将其修改为字母 X。
解法1：深度优先搜索
我们可以使用深度优先搜索实现标记操作。
在下面的代码中，我们把标记过的字母 O 修改为字母 A。
代码：
/*
* @lc app=leetcode.cn id=130 lang=cpp
*
* [130] 被围绕的区域
*/
// @lc code=start
class Solution
{
public:
// 主函数
void solve(vector<vector<char>> &board)
{
if (board.empty())
return;
int m = board.size(), n = m ? board[0].size() : 0;
for (int i = 0; i < m; i++)
{
dfs(board, i, 0);
dfs(board, i, n - 1);
}
for (int j = 0; j < n; j++)
{
dfs(board, 0, j);
dfs(board, m - 1, j);
}
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
{
if (board[i][j] == 'A')
board[i][j] = 'O';
else if (board[i][j] == 'O')
board[i][j] = 'X';
}
}
// 辅函数
void dfs(vector<vector<char>> &board, int x, int y)
{
int m = board.size(), n = m ? board[0].size() : 0;
if (x < 0 || x >= m || y < 0 || y >= n || board[x][y] != 'O')
return;
board[x][y] = 'A';
dfs(board, x + 1, y);
dfs(board, x - 1, y);
dfs(board, x, y + 1);
dfs(board, x, y - 1);
}
};
// @lc code=end
结果：
复杂度分析：
时间复杂度：O(n×m)，其中 n 和 m 分别为矩阵的行数和列数。深度优先搜索过程中，每一个点至多只会被标记一次。
空间复杂度：O(n×m)，其中 n 和 m 分别为矩阵的行数和列数。主要为深度优先搜索的栈的开销。
解法2：广度优先搜索
我们可以使用广度优先搜索实现标记操作。在下面的代码中，我们把标记过的字母 O 修改为字母 A。
代码：
/*
* @lc app=leetcode.cn id=130 lang=cpp
*
* [130] 被围绕的区域
*/
// @lc code=start
// DFS
// class Solution
// {
// public:
// // 主函数
// void solve(vector<vector<char>> &board)
// {
// if (board.empty())
// return;
// int m = board.size(), n = m ? board[0].size() : 0;
// for (int i = 0; i < m; i++)
// {
// dfs(board, i, 0);
// dfs(board, i, n - 1);
// }
// for (int j = 0; j < n; j++)
// {
// dfs(board, 0, j);
// dfs(board, m - 1, j);
// }
// for (int i = 0; i < m; i++)
// for (int j = 0; j < n; j++)
// {
// if (board[i][j] == 'A')
// board[i][j] = 'O';
// else if (board[i][j] == 'O')
// board[i][j] = 'X';
// }
// }
// // 辅函数
// void dfs(vector<vector<char>> &board, int x, int y)
// {
// int m = board.size(), n = m ? board[0].size() : 0;
// if (x < 0 || x >= m || y < 0 || y >= n || board[x][y] != 'O')
// return;
// board[x][y] = 'A';
// dfs(board, x + 1, y);
// dfs(board, x - 1, y);
// dfs(board, x, y + 1);
// dfs(board, x, y - 1);
// }
// };
// BFS
class Solution
{
private:
vector<int> direction{-1, 0, 1, 0, -1};
public:
// 主函数
void solve(vector<vector<char>> &board)
{
if (board.empty())
return;
int m = board.size(), n = m ? board[0].size() : 0;
queue<pair<int, int>> q;
// 从最外围开始，初始化队列
for (int i = 0; i < m; i++)
{
if (board[i][0] == 'O')
{
q.push(pair<int, int>{i, 0});
board[i][0] = 'A';
}
if (board[i][n - 1] == 'O')
{
q.push(pair<int, int>{i, n - 1});
board[i][n - 1] = 'A';
}
}
for (int j = 0; j < n; j++)
{
if (board[0][j] == 'O')
{
q.push(pair<int, int>{0, j});
board[0][j] = 'A';
}
if (board[m - 1][j] == 'O')
{
q.push(pair<int, int>{m - 1, j});
board[m - 1][j] = 'A';
}
}
// BFS遍历
while (!q.empty())
{
auto [r, c] = q.front();
q.pop();
for (int k = 0; k < 4; k++)
{
int x = r + direction[k], y = c + direction[k + 1];
if (x < 0 || x >= m || y < 0 || y >= n || board[x][y] != 'O')
continue;
q.push(pair<int, int>{x, y});
board[x][y] = 'A';
}
}
// 最终修改
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
{
if (board[i][j] == 'A')
board[i][j] = 'O';
else if (board[i][j] == 'O')
board[i][j] = 'X';
}
}
};
// @lc code=end
结果：
复杂度分析：
时间复杂度：O(n×m)，其中 n 和 m 分别为矩阵的行数和列数。广度优先搜索过程中，每一个点至多只会被标记一次。
空间复杂度：O(n×m)，其中 n 和 m 分别为矩阵的行数和列数。主要为广度优先搜索的队列的开销。
