Surrounded Regions

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相连的就是没有被包围的。这里用的是BFS从四个边界进行BFS找出与边界O相连的做好标记，这里是将其变成Z。
BFS完成以后这个board 进行遍历，如果是Z则变成O，其余的都变成X
BFS使用一个队列，将其周围满足条件的都加入到队列中，这里不用使用递归

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
    private char board[][];
    private int rows;
    private int cols;                                                        //行和列数
    private Queue<Integer> queue = new LinkedList<Integer>();                //BFS使用的队列
    
    public void solve(char[][] board) {
        this.board = board;
        if(null == board || board.length == 0 || board[0].length == 0)        //特殊的直接返回
            return;
        rows = this.board.length;
        cols = this.board[0].length;                                        //获取行和列的数目
        
        for(int i = 0; i < rows; i++){
            traver(i, 0);                                                    //第一列
            traver(i, cols - 1);                                            //最后一列
        }
        for(int i = 0; i < cols; i++){
            traver(0, i);                                                    //第一行
            traver(rows - 1, i);                                            //最后一行
        }
        //遍历整个数组
        for(int i = 0; i < rows;i++){
            for(int j = 0; j < cols; j++){
                board[i][j] = this.board[i][j] == 'Z' ? 'O' : 'X';
            }
        }
    }
    
    /**
     * 对x,y所指的单元进行BFS
     * @param x
     * @param y
     */
    public void traver(int x, int y){
        add(x, y);
        while(!this.queue.isEmpty()){
            int head = queue.poll();                                        //出队列
            int temp_x = head / cols;
            int temp_y = head % cols;
            add(temp_x - 1, temp_y);
            add(temp_x + 1, temp_y);
            add(temp_x, temp_y - 1);
            add(temp_x, temp_y + 1);                                        //flood fill算法的体现
        }
    }
    
    /**
     * x,y所指的单元如果是'o'放到队列中,x * cols + y
     * @param x
     * @param y
     */
    public void add(int x, int y){
        if(x >= 0 && x < rows && y >= 0 && y < cols && this.board[x][y] == 'O')
        {
            this.queue.add(x * cols + y);
            this.board[x][y] = 'Z';
        }
    }
    
}

BFS, FLOOD FILL...待续

参考：http://blog.csdn.net/pickless/article/details/12074363

洪泛算法参考：http://blog.sina.com.cn/s/blog_7506816f0100pqzn.html

http://blog.csdn.net/jia20003/article/details/8908464