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

问题来源

此题来源于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的做法是希望在思路上给出一个新的角度~
如有不足，还请指正~