LeetCode__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'变成'X'，因此这题的解法就是搜索边界上的字符'O',并找出所有与边界字符'O'连通的字符'O',将这些字符做个标记，最后再次遍历此2D board，将所有字符'O'变成'X',并将刚才做标记的字符变换为原来的'O'.所以关键是找出所有与边界上'O'字符连通的'O'字符，这是图的遍历问题，可以用DFS或BFS方法，注意用DFS遍历的时候最好要用堆栈而不是递归，我刚开始用递归时，当矩阵大于250*250时，出现了stackoverflow问题。接下来上代码：

1.递归版DFS(RunTimeError)

class Solution {
public:
	void solve(vector<vector<char> > &board) 
	{
		int m = board.size();
		if (m < 3)
			return;
		int n = board[0].size();
		if (n < 3)
			return;
		for (int i = 1; i < m - 1; i++)
		{
			dfs(board, i, 0);
			dfs(board, i, n - 1);
		}
		for (int j = 0; j < n; j++)
		{
			dfs(board, 0, j);
			dfs(board, m - 1, j);
		}
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (board[i][j] == 'O') board[i][j] = 'X';
				else if (board[i][j] == 'A') board[i][j] = 'O';
			}
		}
	}
private:
	void dfs(vector<vector<char> > &board, int x, int y)
	{
		if (x<0 || x >= board.size()|| y < 0 || y >= board[0].size())
			return;
		if (board[x][y] == 'O')
		{
			board[x][y] = 'A';
			dfs(board, x - 1, y);
			dfs(board, x + 1, y);
			dfs(board, x, y - 1);
			dfs(board, x, y + 1);
		}
	}
};

2.用堆栈实现DFS（Accept）

class Solution {
public:
	void solve(vector<vector<char> > &board) 
	{
		int m = board.size();
		if (m < 3)
			return;
		int n = board[0].size();
		if (n < 3)
			return;

		for (int i = 1; i < m - 1; i++)
		{
			dfs(board, i, 0);
			dfs(board, i, n - 1);
		}
		for (int j = 0; j < n; j++)
		{
			dfs(board, 0, j);
			dfs(board, m - 1, j);
		}
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (board[i][j] == 'O') 
					board[i][j] = 'X';
				else if (board[i][j] == 'A') 
					board[i][j] = 'O';
			}
		}
	}
private:
	stack<int> st;
	void dfs(vector<vector<char> > &board, int x, int y)
	{
		fill_stack(board, x, y);
		while (!st.empty())
		{
			int curr = st.top();
			st.pop();
			int i = curr / board[0].size();
			int j = curr % board[0].size();

			fill_stack(board, i - 1, j);
			fill_stack(board, i + 1, j);
			fill_stack(board, i, j - 1);
			fill_stack(board, i, j + 1);
		}
	}

	void fill_stack(vector<vector<char> > &board, int x, int y)
	{
		if (x < 0 || x >= board.size() || y<0 || y >= board[0].size() || board[x][y] != 'O')
			return;
		st.push(x*board[0].size() + y);
		board[x][y] = 'A';
	}
};

3.BFS

class Solution {
public:
	void solve(vector<vector<char> > &board) 
	{
		int m = board.size();
		if (m < 3)
			return;
		int n = board[0].size();
		if (n < 3)
			return;

		for (int i = 1; i < m - 1; i++)
		{
			bfs(board, i, 0);
			bfs(board, i, n - 1);
		}
		for (int j = 0; j < n; j++)
		{
			bfs(board, 0, j);
			bfs(board, m - 1, j);
		}
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (board[i][j] == 'O') 
					board[i][j] = 'X';
				else if (board[i][j] == 'A') 
					board[i][j] = 'O';
			}
		}
	}
private:
	queue<int> Que;
	void fill(vector<vector<char> > &board, int x, int y){
		if (x < 0 || x >= board.size() || y<0 || y >= board[0].size() || board[x][y] != 'O') 
			return;
		Que.push(x*board[0].size() + y);
		board[x][y] = 'A';
	}

	void bfs(vector<vector<char> > &board,int x, int y){
		fill(board, x, y);

		while (!Que.empty()){
			int curr = Que.front();
			Que.pop();
			int i = curr / board[0].size();
			int j = curr % board[0].size();

			fill(board, i - 1, j);
			fill(board, i + 1, j);
			fill(board, i, j - 1);
			fill(board, i, j + 1);
		}
	}
};