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 XX O O XX X O XX O X X

After running your function, the board should be:

X X X XX X X XX X X XX O X X

不知道怎么地这个题一直放着没做。。。读一下题以后发现不难么，bfs或者dfs就可以了，一个数组来标识该点有没有被访问过。

记录下来所有访问过的点，以及一个标识flag，flag表示该点是不是在矩阵的边缘，如果在矩阵的边缘，则相应的连通块没有被X包围，不改动。

如果这个连通块的所有点都不在矩阵边缘，则应该将这个连通块全置为‘X’。

这里，如果是用bfs，则每次bfs完以后，将head置0，然后遍历队列里面的点，就是整个连通块。

如果用dfs，需要维护一个数组，则每次访问一个“有效”点，将这个点加入到这个数组中，然后再统一进行修改或不改动。

而这个题目，我用bfs ac以后，想着写一下dfs，果然，stack over flow了，看来在矩阵上想要进行dfs，矩阵规模稍大就会跪。。还是bfs来的靠谱，除非，将dfs改写成非递归。

class Solution {public:    int row[50000];    int col[50000];    bool flag;    bool** used;    bool valid(vector<vector<char>> &board,int r,int c){        if(r<board.size() && c<board[0].size() && r>=0 && c>=0 && used[r][c]==false &&board[r][c]=='O'){            used[r][c] = true;            return true;        }        return false;    }    int dir[4][2] = {{-1,0},{1,0},{0,-1},{0,1}};    void bfs(vector<vector<char>> &board,int r,int c){        int head = 0;        int tail = 0;            row[tail] = r;        col[tail++] = c;        flag = (r>0 && r<board.size()-1 &&c>0 && c<board[0].size()-1);        while(head!=tail){            int r2 = row[head];            int c2 = col[head];            head++;            for(int i=0;i<4;i++){                if(valid(board,r2+dir[i][0],c2+dir[i][1])){                    int x = r2+dir[i][0];                    int y = c2+dir[i][1];                    row[tail] = x;                    col[tail++] = y;                    flag = flag && x>0 && x<board.size()-1 && y>0 && y<board[0].size()-1;                }            }        }        if(flag){            for(int head=0;head<tail;head++){                board[row[head]][col[head]] = 'X';            }        }    }    void solve(vector<vector<char>> &board) {        int m = board.size();        if(m==0)            return;        int n = board[0].size();        used = new bool*[m];        for(int i=0;i<m;i++){            used[i] = new bool[n];            for(int j=0;j<n;j++)                used[i][j] = false;        }        for(int i=0;i<m;i++){            for(int j=0;j<n;j++){                if(used[i][j]==true || board[i][j]=='X')                    continue;                else{                    bfs(board,i,j);                }            }        }    }};

接下来再贴一份用非递归实现的dfs

class Solution {public:    bool** used;    bool flag = true;    vector<int> row;    vector<int> col;    int row_stack[50000];    int col_stack[50000];    int top = 0;    int dir[4][2] = {{0,-1},{0,1},{-1,0},{1,0}};    bool valid(vector<vector<char>> &board,int r,int c){        return r>=0 && c>=0 && r<board.size() && c<board[0].size() && board[r][c]=='O' && !used[r][c];    }        void dfs(vector<vector<char>> &board,int r,int c){        top=0;        flag = true;        used[r][c] = true;        row_stack[top] = r;        col_stack[top++] = c;        flag = flag && r>0 && r<board.size()-1 && c>0 && c<board[0].size()-1;        row.push_back(r);        col.push_back(c);        while(top>0){            int i = row_stack[--top];            int j = col_stack[top];            for(int k=0;k<4;k++){                int x = i+dir[k][0];                int y = j+dir[k][1];                if(valid(board,x,y)){                    used[x][y]=true;                    flag = flag && x>0 && x<board.size()-1 && y>0 && y<board[0].size()-1;                    row_stack[top] = x;                    col_stack[top++] = y;                    row.push_back(x);                    col.push_back(y);                }            }        }        if(flag){            for(int i=0;i<row.size();i++)                board[row[i]][col[i]]='X';        }        row.clear();        col.clear();    }        void solve(vector<vector<char>> &board) {        int m = board.size();        if(m==0)            return;        int n = board[0].size();        used = new bool*[m];        for(int i=0;i<m;i++){            used[i] = new bool[n];            for(int j=0;j<n;j++)                used[i][j] = false;        }        for(int i=0;i<m;i++){            for(int j=0;j<n;j++){                if(used[i][j]==true || board[i][j]=='X')                    continue;                else{                    dfs(board,i,j);                }            }        }    }};

事实证明，不是dfs差，而是用递归的dfs对栈的需求比较大，如果用迭代来实现的话，和bfs就没有性能上的区别了。。