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

分析：这是一道图论题。由题可知，若O的连通区域能到达边缘，那么这个区域就不变为X，那么遍历图的四个边缘，由这些边缘上的O开始搜索O的区域，将这些O标记为不变，之后再将剩余的O变为X即可。

几个细节：

1、搜索到的不用变化的O先标记为#，然后将图中的O变为X，再将#变为O，这样就不需要额外开辟空间了
2、若用递归实现dfs，测试数据会造成堆栈溢出，所以只能用迭代方法

方法一：利用stack实现迭代的dfs方法

class Solution {  
private:  
    int n,m;  
    void dfs(vector<vector<char>> &bd,int x,int y)  
    {  
        bd[x][y] = '#';  
        stack<pair<int,int> > st;  
        st.push(make_pair(x,y));  
        while(!st.empty())  
        {  
            pair<int,int> now = st.top();  
            st.pop();  
            x = now.first;  
            y = now.second;  
            if(x>0 && bd[x-1][y]=='O') {st.push(make_pair(x-1,y));bd[x-1][y] = '#';}  
            if(x<n-1 && bd[x+1][y]=='O') {st.push(make_pair(x+1,y));bd[x+1][y] = '#';}  
            if(y>0 && bd[x][y-1]=='O') {st.push(make_pair(x,y-1));bd[x][y-1] = '#';}  
            if(y<m-1 && bd[x][y+1]=='O') {st.push(make_pair(x,y+1));bd[x][y+1] = '#';}  
        }  
    }  
    void change(vector<vector<char>> &bd,char ori,char cur)  
    {  
        for(int i=0; i<n; i++)  
            for(int j=0; j<m; j++)  
                if(bd[i][j]==ori)  
                    bd[i][j] = cur;  
    }  
public:  
    void solve(vector<vector<char>> &board) {  
        n = board.size();  
        if(n==0) return;  
        m = board[0].size();  
        if(m==0) return;  
          
        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 i=0; i<m; i++)  
        {  
            if(board[0][i]=='O') dfs(board,0,i);  
            if(board[n-1][i]=='O') dfs(board,n-1,i);  
        }  
        change(board,'O','X');  
        change(board,'#','O');  
    }  
};  

方法二：利用queue实现迭代的bfs方法

class Solution {  
private:  
    int n,m;  
    void bfs(vector<vector<char>> &bd,int x,int y)  
    {  
        bd[x][y] = '#';  
        queue<pair<int,int> > qu;  
        qu.push(make_pair(x,y));  
        while(!qu.empty())  
        {  
            pair<int,int> now = qu.front();  
            qu.pop();  
            x = now.first;  
            y = now.second;  
            if(x>0 && bd[x-1][y]=='O') {qu.push(make_pair(x-1,y));bd[x-1][y] = '#';}  
            if(x<n-1 && bd[x+1][y]=='O') {qu.push(make_pair(x+1,y));bd[x+1][y] = '#';}  
            if(y>0 && bd[x][y-1]=='O') {qu.push(make_pair(x,y-1));bd[x][y-1] = '#';}  
            if(y<m-1 && bd[x][y+1]=='O') {qu.push(make_pair(x,y+1));bd[x][y+1] = '#';}  
        }  
    }  
    void change(vector<vector<char>> &bd,char ori,char cur)  
    {  
        for(int i=0; i<n; i++)  
            for(int j=0; j<m; j++)  
                if(bd[i][j]==ori)  
                    bd[i][j] = cur;  
    }  
public:  
    void solve(vector<vector<char>> &board) {  
        n = board.size();  
        if(n==0) return;  
        m = board[0].size();  
        if(m==0) return;  
          
        for(int i=0; i<n; i++)  
        {  
            if(board[i][0]=='O') bfs(board,i,0);  
            if(board[i][m-1]=='O') bfs(board,i,m-1);  
        }  
        for(int i=0; i<m; i++)  
        {  
            if(board[0][i]=='O') bfs(board,0,i);  
            if(board[n-1][i]=='O') bfs(board,n-1,i);  
        }  
        change(board,'O','X');  
        change(board,'#','O');  
    }  
};  

参考：http://blog.csdn.net/maverick1990/article/details/28275973

          http://blog.csdn.net/werweqg/article/details/45312789