leetcode[C++]Surrounded Regions

Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'.
A region is captured by flipping all 'O's into 'X's in that surrounded region.

For example,
X X X X
X O O X
X X O X
X O X X
After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

题目大意：给定一个矩形，将‘X’字符包围的‘O’字符变成‘X’字符。

解题思路：首先，当矩形的大小小于等于2x2时，矩形是无需改变的，直接返回。其次，我们应该从矩形的边缘开始搜索，即在矩形边缘（矩形最外层的四条边）上的字符‘O’以及和边缘上的字符挨着（所谓挨着，即从上下左右四个方向的任意一个方向出发可以到达该字符，且路径上全是‘O’字符）的字符‘O’一定不会被包围。综上，我们可以从矩形的边缘出发，标记出不能被包围的‘O’字符，最后遍历一遍矩形把被包围的‘O’字符变成‘X’，而被标记的字符还原成‘O’字符。我们可以使用DFS和BFS来标记没有被包围的‘O’字符。

AC代码：

class Solution {
public:
    void helper(vector<vector<char>>&board,int i,int j)//dfs搜索
    {

        if(i>1)
        {
            if(board[i][j]=='O')
            {
                board[i][j]='*';
                helper(board,i-1,j);
                board[i][j]='O';//这里为什么要在还原成‘O’字符，是因为如果从i,j出发可能四个方向都可以扩展，如果此处不还原成‘O’字符，会影响到其他方向的扩展。
            }
        }
        
        if(i<board.size()-1)
        {
            if(board[i][j]=='O')
            {
                board[i][j]='*';
                helper(board,i+1,j);
                board[i][j]='O';
            }
        }
        
        if(j>1)
        {
            if(board[i][j]=='O')
            {
                board[i][j]='*';
                helper(board,i,j-1);
                board[i][j]='O';
            }
        }
        
        if(j<board[0].size()-1)
        {
            if(board[i][j]=='O')
            {
                board[i][j]='*';
                helper(board,i,j+1);
                board[i][j]='O';
            }
        }
        if(board[i][j]=='O')
        {
            board[i][j]='*';
        }//四个方向都扩展完以后，重新标记该字符。
        
    }
    void solve(vector<vector<char>>& board) {
        int row=board.size();
        if(row==0)
            return;
        int col=board[0].size();
        
      if(row <=2 || col <=2)  return; //直接返回。
        for(int i=0;i!=row;++i)
        {
            helper(board,i,0);
            helper(board,i,col-1);
        }
        
        for(int j=0;j!=col;++j)
        {
            helper(board,0,j);
            helper(board,row-1,j);
        }
        //对边缘开始搜索。
        for(int i=0;i!=row;++i)
            for(int j=0;j!=col;++j)
            {
                if(board[i][j]=='*')
                    board[i][j]='O';
                else if(board[i][j]=='O')
                {
                    board[i][j]='X';
                }
            }

    }
};

本解法的dfs代码显得比较冗余，应该可以做一些简化，网上有类似如下的dfs搜索代码，但我在leetcode跑的时候，会报runtime error，个人觉得可能是递归层次太多造成的，代码如下：

    void searchMark(int x, int y, vector<vector<char>> &board){
        if(x < 0 || x >= board.size() || y < 0 || y >= board[x].size())
            return;
        if(board[x][y] == 'O'){
            board[x][y] = '1';
            searchMark(x, y - 1, board);
            searchMark(x, y + 1, board);
            searchMark(x + 1, y, board);
            searchMark(x - 1, y, board);
        }
    }