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);
		}
	}
};