【一天一道LeetCode】#130. Surrounded Regions

一天一道LeetCode

本系列文章已全部上传至我的github，地址：ZeeCoder‘s Github
欢迎大家关注我的新浪微博，我的新浪微博
欢迎转载，转载请注明出处

（一）题目

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’全部转换成‘X’

需要注意被’X‘包围必须是上下左右都被包围。

这道题我最开始的做法是：遍历整个棋盘，当碰到一个’O‘之后，就采用广度搜索的方法，从上下左右四个方向上进行搜索，为’O‘就标记下来，如果搜索过程中碰到边界就代表此范围不能被’X‘包围，就不做处理；反之，如果没有碰到边界就把标记下来的’O‘全部转换成’X‘。

这种做法不好之处就是：需要找遍棋盘中所有的’O‘集合。

于是就采用逆向思维，从边界出发，已经判定这块’O’集合为不被’X‘包围的集合，这样就大大减少了搜索量。

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if(board.empty()) return;
        int row = board.size();
        int col = board[0].size();
        for(int i = 0 ; i < row ; i++)//从左、右边界开始往里面搜
        {
            if(board[i][0]=='O') isSurroundendBy(board,row,col,i,0);
            if(board[i][col-1]=='O') isSurroundendBy(board,row,col,i,col-1);
        }
        for(int i = 1 ; i < col-1 ; i++)//从上、下边界开始往里面搜
        {
            if(board[0][i]=='O') isSurroundendBy(board,row,col,0,i);
            if(board[row-1][i]=='O') isSurroundendBy(board,row,col,row-1,i);
        }
        for(int i = 0 ; i < row ; i++)//遍历棋盘，将标记的’1‘还原成’O‘，将’O‘改写成’X‘
        {
            for(int j = 0 ; j < col ;j++)
            {
                if(board[i][j] == 'O') board[i][j] = 'X';
                else if(board[i][j] == '1') board[i][j] = 'O';
           }
        }
    }
    void isSurroundendBy(vector<vector<char>>& board, int& row, int& col, int i, int j)
    {
        if(board[i][j] =='O'){
            board[i][j] = '1';//标记需要修改的’O‘
                //上下左右四个方向搜索
            if (i+1<row&&board[i+1][j]=='O') isSurroundendBy(board, row, col, i+1, j);
            if (i-1>=0&&board[i-1][j]=='O') isSurroundendBy(board, row, col, i-1, j);
            if (j+1<col&&board[i][j+1]=='O') isSurroundendBy(board, row, col, i, j+1);
            if (j-1>=0&&board[i][j-1]=='O') isSurroundendBy(board, row, col, i, j-1);
        }
    }
};

于是兴高采烈的提交代码，结果Runtime Error！

递归的缺点显露出来了，递归深度太深，导致堆栈溢出。

接下来就把递归版本转换成迭代版本，消除递归带来的堆栈消耗。

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        int row = board.size();
        if(row==0) return;
        int col = board[0].size();
        for(int i = 0 ; i < row ; i++)//从左、右边界开始往里面
        {
            if(board[i][0]=='O') isSurroundendBy(board,row,col,i,0);
            if(board[i][col-1]=='O') isSurroundendBy(board,row,col,i,col-1);//从上、下边界开始往里面
        }
        for(int i = 0 ; i < col ; i++)
        {
            if(board[0][i]=='O') isSurroundendBy(board,row,col,0,i);
            if(board[row-1][i]=='O') isSurroundendBy(board,row,col,row-1,i);
        }
        for (int i = 0; i < row; i++)//遍历棋盘修改标记
        {
            for (int j = 0; j < col; j++)
            {
                if (board[i][j] == 'O') board[i][j] = 'X';
                if (board[i][j] == '1') board[i][j] = 'O';
            }
        }
    }
    int X[4] = {-1,0,1,0};//四个方向
    int Y[4] = { 0,-1,0,1 };
    void isSurroundendBy(vector<vector<char>>& board, int& row, int& col, int i, int j)
    {
        stack<pair<int, int>> temp_stack;//用堆栈来存储中间变量
        temp_stack.push(make_pair(i, j));
        board[i][j] = '1';
        while (!temp_stack.empty())//堆栈不为空就代表没有处理完
        {
            int y = temp_stack.top().first;
            int x = temp_stack.top().second;
            temp_stack.pop();//出栈
            for (int idx = 0; idx < 4; idx++)//处理出栈坐标四个方向是否存在‘O’
            {
                int y0 = y + Y[idx];
                int x0 = x + X[idx];
                if (y0 >= 0 && y0 < row&&x0 >= 0 && x0 < col)
                {
                    if (board[y0][x0] == 'O')//为'O'就压栈等待后续处理
                    {
                        board[y0][x0] = '1';
                        temp_stack.push(make_pair(y0, x0));
                    }
                }
            }
        }
    }
};

提交代码，AC，16ms！

更多关于递归和迭代的转换可以参考本人的这篇博文：【数据结构与算法】深入浅出递归和迭代的通用转换思想