[算法分析与设计] leetcode 每周一题: Surrounded Regions

题目链接：https://leetcode.com/problems/surrounded-regions/description/

题目大意：找出矩阵中被X围住的O，将之翻转成X, 注意位于边界的O即使有3个方向被围住，也不算。（不要求对角线围住）

题目思路：

1. 遍历矩阵的最外围，遇到O，则将之反转成#，同时递归遍历这个元素周围的O，遇到反转。

2. 步骤1处理完毕，则遍历整个矩阵，遇到O反转成X，遇到#将之反转成O，注意先后顺序不能搞反。

代码如下：

class Solution {
public:
   
    void solve(vector<vector<char>>& board) {
        if(board.size() == 0) return;
        int rows = board.size();
        int cols = board[0].size();
      
        traversalOutline(board, rows, cols);
        
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                
                if(board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
                else if(board[i][j] == '#') {
                    board[i][j] = 'O';
                }
            }
        }
    }
    void traversalOutline(vector<vector<char>> &board, int rows, int cols) {
        for(int i = 0; i < rows; i++) {
            filter(board, i, 0, rows, cols);
            filter(board, i, cols - 1, rows, cols);

        }
        for(int i = 1; i < cols - 1; i++) {
            filter(board, 0, i, rows, cols);
            filter(board, rows - 1, i, rows, cols);
        }
    }
    void filter(vector<vector<char>> &board, int i, int j, int rows, int cols) {
        if(board[i][j] == 'O') {
            board[i][j] = '#';
        } else return;
        int offset[4][2] = {
                {1,0},{0,1},{-1,0},{0,-1}
            };
        for(int x = 0; x < 4; x++) {
            int newX = i + offset[x][0];
            int newY = j + offset[x][1];
            if(newX < rows && newX >= 0 && newY < cols && newY >= 0) {
               filter(board, newX, newY, rows, cols);
            }
        }
    }

   
};