[Leetcode] 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 '，只要有一边没有被包围都保持原样。

 方法一：DFS，从四周边界开始遇到' O '，就好奇紧邻的元素是否为' O '，然后最后到哪了，判断完一条再去判断另一条，这样整个深搜的思想出来了。参考了Coder Gander。网上关于DFS的一般思路，就是遇到不符和转换要求的' O '先将其换成别的字符（非X），然后最后遍历一次矩阵，遇到' O '换成' X '，遇到别的字符，换成' O '，即可。代码如下：

class Solution {
public:
    void solve(vector<vector<char>> &board) 
    {
        int row=board.size();
        int col=board[0].size();

        if(row<1||col<1)    return;

        for(int i=0;i<row;++i)  //两侧　　　　两侧和上下的深搜可以用两个for循环和一个if条件判断合并
        {
            dfs(board,i,0);
            dfs(board,i,col-1);
        }    

        for(int i=0;i<col;++i)  //上下
        {
            dfs(board,0,i);
            dfs(board,row-1,i);
        }

        for(int i=0;i<row;++i)
            for(int j=0;j<col;++j)
            {
                if(board[i][j]=='*')
                    board[i][j]='O';
                else
                    board[i][j]='X';
            }
    }

    void dfs(vector<vector<char>> &board,int irow,int jcol)
    {
        if(board[irow][jcol]=='O')
        {
            board[irow][jcol]='*';

            if(irow<board.size()-1)     //下
                dfs(board,irow+1,jcol);
            if(jcol<board[0].size()-1)  //右
                dfs(board,irow,jcol+1);
            if(irow>1)                  //上
                dfs(board,irow-1,jcol);
            if(jcol>1)                  //左
                dfs(board,irow,jcol-1);
        }
    }
};

 方法二：BFS，用队列去存放矩阵中元素的下标，以该下标为基础进行广度遍历。参考a83610312，针对他博客中讲的精简代码的方案，参考哎-哭泣的鱼（这里的代码还是没有精简）。

class Solution {
public:
    void solve(vector<vector<char>> &board) 
    {
        int row=board.size();
        int col=board[0].size();

        if(row<3||col<3)  return;

        for(int i=0;i<row;++i)
            for(int j=0;j<col;++j)
            {
                if((board[i][j]=='O')&&(i==0||i==row-1||j==0||j==col-1))
                    BFS(board,i,j);
            }
        
        for(int i=0;i<row;++i)
            for(int j=0;j<col;++j)
            {
                if(board[i][j]=='O')
                    board[i][j]='X';
                else if(board[i][j]=='*')
                    board[i][j]='O';
            }
        
    }

    void BFS(vector<vector<char>> &board,int i,int j)
    {
        board[i][j]='*';

        int m=board.size();
        int n=board[0].size();
        typedef pair<int,int> cooPoint;

        queue<cooPoint> q;
        q.push(cooPoint(i,j));

        while( !q.empty())
        {
            cooPoint temp=q.front();
            q.pop();

            int x=temp.first,y=temp.second;

            if(x>0&&board[x-1][y]=='O')
            {
                q.push(cooPoint(x-1,y));
                board[x-1][y]='*';
            }
            if(x<m-1&&board[x+1][y]=='O')
            {
                q.push(cooPoint(x+1,y));
                board[x+1][y]='*';
            }
            if(y>0&&board[x][y-1]=='O')
            {
                q.push(cooPoint(x,y-1));
                board[x][y-1]='*';
            }
            if(y<n-1&&board[x][y+1]=='O')
            {
                q.push(cooPoint(x,y+1));
                board[x][y+1]='*';
            }
        }

    }
};