LeetCode OJ

我觉得这道题和传统的用动规或者贪心等算法的题目不同。按照题目的意思，就是将被‘X’围绕的‘O’区域找出来，然后覆盖成‘X’。

那问题就变成两个子问题：

1. 找到‘O’区域，可能有多个区域，每个区域‘O’都是相连的；

2. 判断‘O’区域是否是被‘X’包围。

我采用树的宽度遍历的方法，找到每一个‘O’区域，并为每个区域设置一个value值，为0或者1,1表示是被‘X’包围，0则表示不是。是否被‘X’包围就是看‘O’区域的边界是否是在2D数组的边界上。

下面是具体的AC代码:

class BoardNode{
    int x;
    int y;
    public BoardNode(int x, int y){
        this.x = x;
        this.y = y;
    }
}

/**
     * 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.
     * @param board
     */
    public void solve(char[][] board){
        //empty 2D board
        if(board.length == 0)
            return;
        //if value == 1,means the group is surrended by 'X', if value == 0 , means it is not
        HashMap<LinkedList<BoardNode>, Integer> groups = new HashMap<LinkedList<BoardNode>, Integer>();
        int xB = board.length;
        int yB = board[0].length;
        if(xB == 1 || yB == 1)
            return;
        boolean[][] flag = new boolean[xB][yB];
        for(int i=0;i<xB;i++)
            for(int j=0;j<yB;j++)
                flag[i][j] = true;
        for(int i=0;i<xB;i++)
        {
            for(int j=0;j<yB;j++){
                if(board[i][j]=='O' && flag[i][j])
                {
                    //a new group
                    LinkedList<BoardNode> tree = new LinkedList<BoardNode>();
                    //the corresponding value of the group
                    int value = 1;
                    if(i==0 || i==xB-1 || j==0 || j==yB-1)
                        value = 0;
                    //bread first search for the group
                    tree.offer(new BoardNode(i,j));
                    flag[i][j] = false;
                    int point = 0;
                    while(point<tree.size()){
                        BoardNode temp = tree.get(point++);
                        //left neighbor
                        if(temp.y+1==yB-1 && board[temp.x][temp.y+1]== 'O')
                            value = 0;
                        if(temp.y+1<yB && flag[temp.x][temp.y+1] && board[temp.x][temp.y+1]== 'O')
                        {
                            flag[temp.x][temp.y+1] = false;
                            tree.offer(new BoardNode(temp.x,temp.y+1));
                        }
                        //down neighbor
                        if(temp.x+1 == xB-1 && board[temp.x+1][temp.y] == 'O')
                            value = 0;
                        if(temp.x+1<xB && flag[temp.x+1][temp.y] && board[temp.x+1][temp.y] == 'O')
                        {
                             flag[temp.x+1][temp.y]=false;
                            tree.offer(new BoardNode(temp.x+1,temp.y));
                        }
                        //up neighbor
                        if(temp.x-1 == 0 && board[temp.x-1][temp.y]=='O')
                            value = 0;
                        if(temp.x-1>=0 && flag[temp.x-1][temp.y] && board[temp.x-1][temp.y] == 'O'){
                            flag[temp.x-1][temp.y]=false;
                            tree.offer(new BoardNode(temp.x-1,temp.y));
                        }
                        //left neighbor
                        if(temp.y-1==0 && board[temp.x][temp.y-1]=='O')
                            value = 0;
                        if(temp.y-1>=0 && flag[temp.x][temp.y-1] && board[temp.x][temp.y-1]=='O')
                        {
                            flag[temp.x][temp.y-1] = false;
                            tree.offer(new BoardNode(temp.x,temp.y-1));
                        }
                    }
                    groups.put(tree, value);
                }
            }
        }
        //flipping the region surrounded by 'X'
        for(Entry<LinkedList<BoardNode>,Integer> e: groups.entrySet())
        {
            if(e.getValue() == 1)
            {
                for(BoardNode bn : e.getKey())
                    board[bn.x][bn.y] = 'X';
            }
        }
    }