利用BFS和DFS解决 LeetCode 130: Surrounded Regions

问题来源

此题来源于LEETCODE，具体问题详见下面的链接
https://leetcode.com/problems/surrounded-regions/description/

问题简述

给定一个包含字母 X 和 O 的二维矩阵，找到所有被 X 包围的 O 并将被包围的 O 变成 X。
比如给定如下矩阵：

X X X XX O O XX X O XX O X X

在运行程序后希望得到：

X X X XX X X XX X X XX 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                XXXXXOOX   用原问题中的代码会得到       XOXX  正确的应该是   XOOXXOXX   ---------------------->    XOXX  ------------> XOXXXOXX                              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的做法是希望在思路上给出一个新的角度~
如有不足，还请指正~