leetcode130:Surrounded Regions

最新推荐文章于 2016-10-09 11:11:50 发布

tingting256

最新推荐文章于 2016-10-09 11:11:50 发布

阅读量326

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 算法文章标签： leetcode 2d

本文链接：https://blog.youkuaiyun.com/tingting256/article/details/48528091

leetcode 同时被 2 个专栏收录

47 篇文章

订阅专栏

算法

24 篇文章

订阅专栏

本文介绍了一种解决二维棋盘中O被X围攻问题的算法。该算法通过判断O的位置类型（边界O、被完全围困的O和其他O），并利用递归将与边界O相连的O保留下来，最终实现对被围困O的翻转。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

Show Tags

Show Similar Problems

Have you met this question in a real interview?

题目分析：题目简单描述为用X围攻O，是O不是‘0’，我能说我被坑了么。先对O进行分类，边界O仍为O，四周都是X的O已经被围攻了，变为X，剩下的标为1，之后用边界O帮助跟他相关联的1逃脱，变为O，最后再把没有逃脱的1标为X

 public void solve(char[][] board) {
		 int row=board.length;
		 if(row==0) return;
		 int column=board[0].length;
		 if(column==0) return;
		 //把连在一起的O串成一圈，边界的O仍为O
		 for(int i=0;i<row;i++)
		 {
			 for(int j=0;j<column;j++)
			 {
				 if(board[i][j]=='O')
				 {
					 if(judge(i,j,board)==1)
						 board[i][j]='X';
					 else if(judge(i,j,board)==2)
						 board[i][j]='1';
					 
				 }
				 
			 }
		 }
		 //用边界的O递归的把周围的1变成O
		 for(int i=0;i<row;i++)
		 {
			 for(int j=0;j<column;j++)
			 {
				 if(board[i][j]=='O')
				 {
					 change(i,j,board);
					 
				 }
				 
			 }
		 }
		 
		 //最后把没被解决掉的1标为X
		 for(int i=0;i<row;i++)
		 {
			 for(int j=0;j<column;j++)
			 {
				 if(board[i][j]=='1')
				 {
					
						 board[i][j]='X';
					
				 }
				 
			 }
		 }
	    }
	 
	 //判断一个字符属于那一类别，边界的，周围都是X的还有剩余的
	 public int judge(int a,int b,char[][] board)
	 {
		 if(a==0||a==board.length-1) return 0;
		 if(b==0||b==board[0].length-1) return 0;
		 if(board[a-1][b]=='X'&&board[a+1][b]=='X'&&board[a][b-1]=='X'&&board[a][b+1]=='X')
			 return 1;
		 else
			 return 2;
	 }
	 
	 //递归的消灭跟O相关的1
	 public void change(int a,int b,char[][] board)
	 {
		 if(a>0)
		 {
			 if(board[a-1][b]=='1')
			 {
				 board[a-1][b]='O';
				 change(a-1,b,board);
			 }
				 
		 }
		 if(a<board.length-1)
		 {
			 if(board[a+1][b]=='1')
			 {
				 board[a+1][b]='O';
				 change(a+1,b,board);
			 }
				 
		 }
		 if(b>0)
		 {
			 if(board[a][b-1]=='1')
			 {
				 board[a][b-1]='O';
				 change(a,b-1,board);
			 }
				 
		 }
		 if(b<board[0].length-1)
		 {
			 if(board[a][b+1]=='1')
			 {
				 board[a][b+1]='O';
				 change(a,b+1,board);
			 }
				 
		 }
	 }
	 
	 @Test
	 public void case1()
	 {
		 char[][] board={{'X','X','X','X'},
				         {'X','O','O','X'},
				         {'X','X','O','X'},
				         {'X','O','X','X'}};
		 solve(board);
		 char[][] expect={{'X','X','X','X'},
		         {'X','X','X','X'},
		         {'X','X','X','X'},
		         {'X','O','X','X'}};
		 Assert.assertArrayEquals(expect, board);
	 }
	 
	 @Test
	 public void case5()
	 {
		 char[][] board={{'X','O','X','X'},
				         {'O','X','O','X'},
				         {'X','O','X','O'},
				         {'O','X','O','X'},
				         {'X','O','X','O'},
				         {'O','X','O','X'}};
		 solve(board);
char[][] expect={{'X','O','X','X'},
		         {'O','X','X','X'},
		         {'X','X','X','O'},
		         {'O','X','X','X'},
		         {'X','X','X','O'},
		         {'O','X','O','X'}};;
		 Assert.assertArrayEquals(expect, board);
	 }
	 
	 @Test
	 public void case3()
	 {
		 char[][] board={{'X','X','X'},
				         {'X','O','X'},
				         {'X','X','X'}};
		 solve(board);
		 char[][] expect={{'X','X','X'},
		         {'X','X','X'},
		         {'X','X','X'}};
		 Assert.assertArrayEquals(expect, board);
	 }
	 
	 @Test
	 public void case4()
	 {
		 char[][] board={{'O','O'},
				         {'O','O'}};
		 solve(board);
		 char[][] expect={{'O','O'},
		         {'O','O'}};
		 Assert.assertArrayEquals(expect, board);
	 }
	 @Test
	 public void case2()
	 {
		 char[][] board={{'X','X','X','X'},
				         {'X','O','O','X'},
				         {'X','X','O','X'},
				         {'X','O','O','X'}};
		 solve(board);
		 char[][] expect={{'X','X','X','X'},
		         {'X','O','O','X'},
		         {'X','X','O','X'},
		         {'X','O','O','X'}};
		 Assert.assertArrayEquals(expect, board);
	 }
	 @Test
	 public void case6()
	 {
		 char[][] board={{'X','O','O','X'},
				         {'X','O','X','X'}};
		 solve(board);
		 char[][] expect={{'X','O','O','X'},
		         {'X','O','X','X'}};
		 Assert.assertArrayEquals(expect, board);
	 }