LeetCode打卡第三天（130. 被围绕的区域）------广度优先搜索（BFS）+递归

LeetCode打卡第三天（130. 被围绕的区域）

Given a 2D board containing ‘X’ and ‘O’ (the letter O), capture all regions surrounded by ‘X’.

A region is captured by flipping all 'O’s into 'X’s in that surrounded region.

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

Explanation:

Surrounded regions shouldn’t be on the border, which means that any ‘O’ on the border of the board are not flipped to ‘X’. Any ‘O’ that is not on the border and it is not connected to an ‘O’ on the border will be flipped to ‘X’. Two cells are connected if they are adjacent cells connected horizontally or vertically.

解题思路：
1.由图可以看出，不变成‘X’的‘O’有两种，第一种是边界上的，第二种是和边界O相邻的。
2.因此我们可以以边界O为切入点，在矩阵存在范围内，搜索它的上、下、左、右四个方向。如果搜索到的位置值是O，继续搜（递归）。
3.我们把凡是搜索到O的位置进行标记，形成与没有搜索到的O或X的对比，以便最后赋值打印。
4.我们可以看到凡是可以通过递归操作找到的O，必然是边界O关系型O，而非X环绕型O。

步骤分析：
1.建立一个bfs函数。函数功能;在矩阵大小范围内早到值为O的位置，将其标注，并可以递归它四个方向位置的点进行搜索。

void dfs(vector<vector<char>>& board,int x,int y){
        if(x>=0 && x<board.size() && y>=0 && y<board[0].size() && board[x][y]=='O'){
            board[x][y] = '1';//将位置边界O关系型O位置的值标记为‘1’
            dfs(board,x+1,y);
            dfs(board,x-1,y);
            dfs(board,x,y+1);
            dfs(board,x,y-1);
        }

2.从四边开始搜索存在的O，即第一行，最后一行，第一列，最后一列。

for(int i=0;i<n;i++){
            if(board[i][0] == 'O'){
                dfs(board,i,0);
            }
            if(board[i][m-1] == 'O'){
                dfs(board,i,m-1);
            }
        }
        for(int j=0;j<m;j++){
            if(board[0][j]=='O'){
                dfs(board,0,j);
            }
            if(board[n-1][j]=='O'){
                dfs(board,n-1,j);
            }

3.在矩阵范围内将标记为“1”的位置，赋值为O，其他位置赋值为X。

for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(board[i][j]=='1'){
                    board[i][j]='O';
                }else{
                    board[i][j]='X';
                }
            }
        }

代码：

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if(board.size()==0){
            return;
        }
        int n=board.size(),m=board[0].size();
        for(int i=0;i<n;i++){
            if(board[i][0] == 'O'){
                dfs(board,i,0);
            }
            if(board[i][m-1] == 'O'){
                dfs(board,i,m-1);
            }
        }
        for(int j=0;j<m;j++){
            if(board[0][j]=='O'){
                dfs(board,0,j);
            }
            if(board[n-1][j]=='O'){
                dfs(board,n-1,j);
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(board[i][j]=='1'){
                    board[i][j]='O';
                }else{
                    board[i][j]='X';
                }
            }
        }
    }
private:
    void dfs(vector<vector<char>>& board,int x,int y){
        if(x>=0 && x<board.size() && y>=0 && y<board[0].size() && board[x][y]=='O'){
            board[x][y] = '1';
            dfs(board,x+1,y);
            dfs(board,x-1,y);
            dfs(board,x,y+1);
            dfs(board,x,y-1);
        }
    }
};

总结：
1.凡是涉及矩阵（二维数组）搜索、简单计算的问题皆可bfs。
2.bfs的核心在于从起点开始可以呈“+”（上下左右四方向）搜索。常用的搜索方法有两种，一是建立位置数组（用于bfs+队列），二是在方法递归中直接用(x-1,y)、(x+1,y)、(x,y+1)、(x,y-1)带入参数，如本题。