LC-130 被环绕区域

问题：

输入一个矩阵，将被X字符包围的O字符全部替换为X，但是如果某个O字符处于矩阵的边界，则该O字符及其连接的所有O字符都不变。

输出替换后的矩阵。

 

 

思路：

先遍历矩阵每一个字符，当发现O字符，则利用深搜方式找出与之相连的所有O字符。

每找出一个O字符，则先将其改为X字符，并将相连接的四个方向的O字符的坐标存入search栈中。并且将这个替换后的字符的坐标，保存在recover栈中。

在搜索相连接的O字符时，如果发现所连接的是边界字符，则说明这次找到的O字符区域，是不需要改变的，但是因为我们之前都改为X了（为了避免重复搜索字符），所以最后的时候，将找到的这部分字符区域，重新标记为F字符。

最后在检索完所有字符区域后，就将F字符恢复为O字符。

 

代码：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.size() == 0) return;
        rows = board.size();
        cols = board[0].size();
        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 && board[i][j] == 'O') {
                    searchAndRecover(board, i, j);
                }
            }
        }
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (board[i][j] == 'F') {
                    board[i][j] = 'O';
                }
            }
        }
    }
    void searchAndRecover(vector<vector<char>>& board, int x, int y) {
        // intialize
        searching.clear();
        recover.clear();
        int directions[4][2] = {{1, 0}, {0, -1}, {-1, 0}, {0, 1}};
        bool need_recovery = false;
        // store the original one
        pair<int, int> origin(x, y);
        searching.push_back(origin);
        while (!searching.empty()) {
            // get the top of the stack
            pair<int, int> tmp = searching.back();
            searching.pop_back();
            // change the value
            board[tmp.first][tmp.second] = 'X';
            recover.push_back(tmp);
            for (int i = 0; i < 4; i++) {
                int tmp_x = tmp.first + directions[i][0];
                int tmp_y = tmp.second + directions[i][1];
                if (tmp_x >= 0 && tmp_x < rows && tmp_y >= 0 && tmp_y < cols && board[tmp_x][tmp_y] == 'O') {
                    if (tmp_x > 0 && tmp_x < rows - 1 && tmp_y > 0 && tmp_y < cols - 1) {
                        pair<int, int> add_point(tmp_x, tmp_y);
                        searching.push_back(add_point);
                    }
                    else {
                        need_recovery = true;
                    }
                }
            }
        }
        if (need_recovery) {
            while (!recover.empty()) {
                pair<int, int> tmp = recover.back();
                board[tmp.first][tmp.second] = 'F';
                recover.pop_back();
            }
        }
    }
private:
    int rows;
    int cols;
    vector<pair<int, int>> searching;
    vector<pair<int, int>> recover;
};