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.
  (给定一个包含"X"和"O"的二维板，捕捉所有被X包围的区域.被"X"包围的"O"全部翻转为"X".)
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来BFS，然后如果连到边上的O就回溯回去，但是很困难。但是如果从边上看，将与边上O相连的O都标记,没有标记的就肯定被包围了,最后将没有标记过的O替换为X就可以了。但这个题很坑的一点是无法用DFS来寻找并标记与边上O相连的O,LeetCode会显示栈溢出，那么只能使用BFS（并不是DFS是错误的，而是DFS使用的递归会导致栈溢出，看到网上有这么一种说法来解释这种情况：“因为递归用的是程序运行时的堆空间，一般来说分配给程序的堆空间比较小，而非递归则是动态分配空间，相对来说可以使用内存中的空间”）。

DFS解法：

public class Surrounded_Regions {
    public static void solve(char[][] board) 
    {  
    	if(board.length == 0||board[0].length == 0)
    	{
    		return;
    	}
    	int length = board.length;
    	int width = board[0].length;
    	
    	//将边上的O以及与其相连的O都标记为M，意思为这些O不被X包围
    	for(int i=0;i<length;i++)
    	{
    		for(int j=0;j<width;j++)
    		{
    			if(i==0||i==length-1||j==0||j==width-1)
    			{
    				if(board[i][j] == 'O')
    					change(board,i,j);
    			}
    		}
    	}
    	//将没被标记的O都变为X,并将标记去除
    	for(int i=0;i<length;i++)
    	{
    		for(int j=0;j<width;j++)
    		{
    			//这里判断顺序绝对不可以改变
    			//如果先判断M,将该点变为O,那么下一个判断判定该点为O,就会将该点变为X
    			if(board[i][j] == 'O')
    				board[i][j] = 'X';
    			if(board[i][j] == 'M')
    				board[i][j] = 'O';
    		}
    	}
    }
    public static void change(char[][] board,int i,int j)
    {
    	int length = board.length;
    	int width = board[0].length;
    	//从边上的O点向四面寻找与之相连O
    	if(board[i][j] == 'O')
    	{
    		board[i][j] = 'M';
    	}
    	if(i-1>=0&&board[i-1][j] == 'O')
    	{
    		change(board,i-1,j);
    	}
    	if(i+1<length&&board[i+1][j] == 'O')
    	{
    		change(board,i+1,j);
    	}
    	if(j-1>=0&&board[i][j-1] == 'O')
    	{
    		change(board,i,j-1);
    	}
    	if(j+1<width&&board[i][j+1] == 'O')
    	{
    		change(board,i,j+1);
    	}
    }
	public static void main(String[] args) {
		char board[][] = {{'X','X','X','X'},{'X','O','O','X'},{'X','X','O','X'},{'X','O','X','X'}};
		solve(board);
		for(int i=0;i<board.length;i++)  
        {  
            for(int j=0;j<board[0].length;j++)  
            {
            	System.out.print(board[i][j]);
            }
            System.out.println("\n");
        }
	}
}

BFS解法：

public class Surrounded_Regions2 {
	public static void solve(char[][] board) 
    {  
    	if(board.length == 0||board[0].length == 0)
    	{
    		return;
    	}
    	int length = board.length;
    	int width = board[0].length;
    	
    	//将边上的O以及与其相连的O都标记为M，意思为这些O不被X包围
    	for(int i=0;i<length;i++)
    	{
    		for(int j=0;j<width;j++)
    		{
    			if(i==0||i==length-1||j==0||j==width-1)
    			{
    				if(board[i][j] == 'O')
    					change(board,i,j);
    			}
    		}
    	}
    	//将没被标记的O都变为X,并将标记去除
    	for(int i=0;i<length;i++)
    	{
    		for(int j=0;j<width;j++)
    		{
    			//这里判断顺序绝对不可以改变
    			//如果先判断M,将该点变为O,那么下一个判断判定该点为O,就会将该点变为X
    			if(board[i][j] == 'O')
    				board[i][j] = 'X';
    			if(board[i][j] == 'M')
    				board[i][j] = 'O';
    		}
    	}
    }
    public static void change(char[][] board,int i,int j)
    {
    	int length = board.length;
    	int width = board[0].length;
    	board[i][j] = 'M';
    	//用来存储与边上的O相连的O的x和y
    	ArrayList<Integer> ListX = new ArrayList<Integer>();
    	ArrayList<Integer> ListY = new ArrayList<Integer>();
    	ListX.add(i);
    	ListY.add(j);
    	//从边上的O点向四面寻找与之相连O
    	while(ListX.size()>0)
    	{
    		int x = ListX.get(0);
    		int y = ListY.get(0);
    		ListX.remove(0);
    		ListY.remove(0);
    		if(x-1>=0&&board[x-1][y] == 'O')
    		{
    			board[x-1][y] = 'M';
    			ListX.add(x-1);
    			ListY.add(y);
    		}
    		if(x+1<length&&board[x+1][y] == 'O')
    		{
    			board[x+1][y] = 'M';
    			ListX.add(x+1);
    			ListY.add(y);
    		}
    		if(y-1>=0&&board[x][y-1] == 'O')
    		{
    			board[x][y-1] = 'M';
    			ListX.add(x);
    			ListY.add(y-1);
    		}
    		if(y+1<width&&board[x][y+1] == 'O')
    		{
    			board[x][y+1] = 'M';
    			ListX.add(x);
    			ListY.add(y+1);
    		}
    	}
    }
	public static void main(String[] args) {
		char board[][] = {{'X','X','X','X'},{'X','O','O','O'},{'X','X','O','X'},{'X','O','X','X'}};
		solve(board);
		for(int i=0;i<board.length;i++)  
        {  
            for(int j=0;j<board[0].length;j++)  
            {
            	System.out.print(board[i][j]);
            }
            System.out.println("\n");
        }
	}
}

不难看出无论BFS还是DFS都是由点到面扩散出去去寻找符合条件的点，只不过DFS用递归，而BFS使用一个ArrayList来保存这些点，内涵一样表现形式不同。