LeetCode——130. 被围绕的区域

题目

给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。

找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。
示例:

X X X X
X O O X
X X O X
X O X X

运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X

解释:
被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

思路

这道题，无非就想找出那些地方位置为’O’可以被填充为’X’,但是这些位置如果按照传统的想法，直接找的话，可能难以找出来，那我们倒不如换一种思路，图中的’O’,在经历算法之后，无非就两种情况，一个种可以转换为’X’【这种直接找的难度比较大】，一种是不可以转化为’X’.如果我们能把这些不能转化为’X’的’O’，找出来，剩下的，不就全是可以转化的了。

看到那个解释，其实眼前一亮，我们可以找到边界的’O’，并且进行广搜，只要能够广搜到的’O’都是不能转化的。我们可以开一个标记数组，标记为2，到时候，再遍历一遍进行转化即可。

代码

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

class Point
{
    int x;
    int y;
    public Point(int x,int y)
    {
        this.x=x;
        this.y=y;
    }
}
//被围绕的区域
class Solution {
    static int row;
    static int column;
    static char[][]map=new char[1000][1000];
    static int visited[][]=new int[1000][1000];//标记数组

    static int direction[][]={{0,1},{1,0},{0,-1},{-1,0}};

    static Queue<Point>queue=new LinkedList();

    public void solve(char[][] board) {
        if (board.length==0 || board[0].length==0)
            return;
        row=board.length;
        column=board[0].length;


        //初始化标记数组
        for (int i=0;i<row;++i)
            for (int j=0;j<column;++j)
            {
                visited[i][j]=0;
                map[i][j]=board[i][j];
            }

        for (int i=0;i<row;++i)
        {
            if (board[i][0]=='O' && visited[i][0]==0)
            {
                queue.add(new Point(i,0));
                visited[i][0]=2;
                bfs();
            }
            if (board[i][column-1]=='O' && visited[i][column-1]==0)
            {
                queue.add(new Point(i,column-1));
                visited[i][column-1]=2;
                bfs();
            }
        }

        for (int j=0;j<column;++j)
        {
            if (board[0][j]=='O' && visited[0][j]==0)
            {
                queue.add(new Point(0,j));
                visited[0][j]=2;
                bfs();
            }
            if (board[row-1][j]=='O' && visited[row-1][j]==0)
            {
                queue.add(new Point(row-1,j));
                visited[row-1][j]=2;
                bfs();
            }

        }

        for (int i=0;i<row;++i)
        {
            for (int j=0;j<column;++j)
            {
                if (board[i][j]=='O' && visited[i][j]!=2)
                {
                    board[i][j]='X';
                }
            }
        }
    }

    public void bfs()
    {
        while (!queue.isEmpty())
        {
            Point temp=queue.poll();
            int t_x=0;
            int t_y=0;
            for (int g=0;g<=3;++g)
            {
                t_x=temp.x+direction[g][0];
                t_y=temp.y+direction[g][1];
                if (check(t_x,t_y))
                {
                    queue.add(new Point(t_x,t_y));
                    visited[t_x][t_y]=2;
                }
            }
        }

    }
    public boolean check(int x,int y)
    {
        return x>=0 && x<row && y>=0 && y<column && visited[x][y]==0 && map[x][y]=='O';
    }
}

结果

AC了倒是AC了，只不过中间有一个坑点是我从来都没有发现的。今天发现了。。

第三次，提交结果出现超出时间限制，我就在看代码到底哪里出了问题。根本原因就在于，我是先进入搜索队列，完了在弹出的那一个时刻顺便把标记数组给标记为2.其实这种做法在问题处理规模很小的时候不会出现问题，但是问题规模很大的时候，就会出现没有标记的点被反复加入到搜索队列中，造成死循环。