问题来源
此题来源于LEETCODE,具体问题详见下面的链接
https://leetcode.com/problems/surrounded-regions/description/
问题简述
给定一个包含字母 X 和 O 的二维矩阵,找到所有被 X 包围的 O 并将被包围的 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 出发,遍历所有与之相连的 O,并做上标记,然后遍历整个矩阵,将未做标记的 O 变成 X 即可。
下面提供两种遍历的思路,分别是BFS和DFS。
利用BFS来解决
首先来说BFS,这个方法在LEETCODE上运行是可以得到一个ACCEPTED的,其代码如下:
class Solution {
private:
int m;
int n;
//用来决定移动的方向
int d[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
private:
//判断是否在矩阵内
bool inArea(int x, int y){
return x >= 0 && y >= 0 && x < m && y < n;
}
void bfs(vector<vector<char>>& board, int x, int y){
//构建一个队列来存放遍历的节点
queue< pair<int, int> > q;
q.push( make_pair(x, y) );
board[x][y] = 'M';
//用BFS遍历相邻的O,并标记为M
while( !q.empty() ){
int curX = q.front().first;
int curY = q.front().second;
q.pop();
for (int i = 0; i < 4; i++){
int newX = curX + d[i][0];
int newY = curY + d[i][1];
if (inArea(newX, newY) && board[newX][newY] == 'O'){
q.push( make_pair(newX, newY) );
board[newX][newY] = 'M';
}
}
}
return;
}
public:
void solve(vector<vector<char>>& board) {
m = board.size();
if (m == 0)
return;
n = board[0].size();
if (n == 0)
return;
//遍历左右两列
for (int i = 0; i < m; i++){
if (board[i][0] == 'O')
bfs(board, i, 0);
if (board[i][n - 1] == 'O')
bfs(board, i, n - 1);
}
//遍历上下两行
for (int i = 0; i < n; i++){
if (board[0][i] == 'O')
bfs(board, 0, i);
if (board[m - 1][i] == 'O')
bfs(board, m - 1, i);
}
//将未被标记成M的O变成X,并把M变回O
for (int i = 0; i < m; i++){
for (int j = 0; j < n; j++){
if (board[i][j] == 'O')
board[i][j] = 'X';
if (board[i][j] == 'M')
board[i][j] = 'O';
}
}
return;
}
};
利用DFS来解决
可以看到BFS要将矩阵遍历多次,时间复杂度就上去了。
下面提供一种更为有意思的思路(虽然是有些问题的~)
大致思路为先找到一个 O 并将其变成 X,如果这个 O 利用DFS可以走到边缘,那么在再把它变回 O,然后再继续找没有被遍历过的 O。
代码如下:
class Solution {
private:
int m;
int n;
vector<vector<bool>> visited;
int d[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
private:
bool inArea(int x, int y){
return x >= 0 && y >= 0 && x < m && y < n;
}
bool dfs(vector<vector<char>> &board, int x, int y){
visited[x][y] = true;
board[x][y] = 'X';
for (int i = 0; i < 4; i++){
int newX = x + d[i][0];
int newY = y + d[i][1];
if (!inArea(newX, newY)){
board[x][y] = 'O';
return false;
}
if (board[newX][newY] == 'O' && !dfs(board, newX, newY)){
board[x][y] = 'O';
return false;
}
}
return true;
}
public:
void solve(vector<vector<char>>& board) {
m = board.size();
if (m <= 0)
return;
n = board[0].size();
visited = vector<vector<bool>>(m, vector<bool>(n, false));
int changedRegion = 0;
for (int i = 0; i < m; i++){
for (int j = 0; j < n; j++){
if (board[i][j] == 'O' && !visited[i][j])
if(dfs(board, i, j))
changedRegion++;
}
}
return;
}
};
怎么样?这个思路是不是很有意思?这个代码在LEETCODE上运行会得到一个RUMTIME ERROR,原因是因为递归层数太多了,栈溢出了。
不过初次之外,还存在一个逻辑上的漏洞,比如一个很简单的测试用例:
XXXX XXXX XXXX
XOOX 用原问题中的代码会得到 XOXX 正确的应该是 XOOX
XOXX ----------------------> XOXX ------------> XOXX
XOXX XOXX XOXX
也就是说有一些 O 点会被误认为是被surrounded的点,被欺骗了~具体的和d[4][2]中的值的顺序有关,但不管顺序如何,都会有这种情况发生。
所以,还是得从边界出发来往内部DFS,虽然这样遍历的情况会变多,但也没办法,下面是我改进后的代码,虽然仍旧无法解决栈溢出的问题,但至少这次的逻辑应该是没问题了~
class Solution {
private:
int m;
int n;
vector<vector<bool>> visited;
int d[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
private:
bool inArea(int x, int y){
return x >= 0 && y >= 0 && x < m && y < n;
}
void dfs(vector<vector<char>> &board, int x, int y){
visited[x][y] = true;
for (int i = 0; i < 4; i++){
int newX = x + d[i][0];
int newY = y + d[i][1];
if (!inArea(newX, newY))
continue;
if (board[newX][newY] == 'O' && !visited[newX][newY])
dfs(board, newX, newY);
}
return;
}
public:
void solve(vector<vector<char>>& board) {
m = board.size();
if (m <= 2)
return;
n = board[0].size();
if (n <= 2)
return;
visited = vector<vector<bool>>(m, vector<bool>(n, false));
for (int i = 1; i < m - 1; i++){
if (board[i][0] == 'O' && !visited[i][0])
dfs(board, i, 0);
if (board[i][n - 1] == 'O' && !visited[i][n - 1])
dfs(board, i, n - 1);
}
for (int i = 1; i < n - 1; i++){
if (board[0][i] == 'O' && !visited[0][i])
dfs(board, 0, i);
if (board[m - 1][i] == 'O' && !visited[m - 1][i])
dfs(board, m - 1, i);
}
for (int i = 1; i < m - 1; i++){
for (int j = 1; j < n - 1; j++){
if (board[i][j] == 'O' && !visited[i][j])
board[i][j] = 'X';
}
}
return;
}
};
结束语
此题用BFS做是比较常规的揭发,我之所以提供无法通过的DFS的做法是希望在思路上给出一个新的角度~
如有不足,还请指正~