Leetcode_surrounded-regions

最新推荐文章于 2019-03-26 22:00:05 发布

fibo_nacci

最新推荐文章于 2019-03-26 22:00:05 发布

阅读量574

点赞数

分类专栏： Leetcode

本文链接：https://blog.csdn.net/flyupliu/article/details/26470243

版权

Leetcode 专栏收录该内容

155 篇文章 0 订阅

订阅专栏

地址： https://oj.leetcode.com/problems/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

思路：这是一道相当让人郁闷的题, 因为我因为TLE和MLE的次数加起来应该差不多有10次了.

我从边界的O开始搜索过，也从内部的O开始搜索过, 基本上都是TLE或者MLE.

后来想到MLE的话看开了哪些空间, 我是一个队列，一个数组，还有递归的栈消耗，这里面基本上时数组比较耗空间, O(N^2),

如果不用visited的数组的话，把边界能访问的O都标记为Y，那么留下的O就应该是被圈住的O，最后遍历的时候将其O改为X，将Y改成O就ok了。

参考代码：

class Solution {
private:
    int row, col;
public:
    void bfs(int r, int c, vector<vector<char>>&board)
    {
        board[r][c] = 'Y';
        queue<pair<int, int>>q;
        q.push(pair<int, int>(r, c));
        pair<int, int>cur;
        while(!q.empty())
        {
            cur = q.front();
            q.pop();
            if(cur.first+1<row && board[cur.first+1][cur.second]=='O')
            {
                board[cur.first+1][cur.second] = 'Y';
                q.push(pair<int, int>(cur.first+1, cur.second));
            }
            if(cur.second+1<col && board[cur.first][cur.second+1]=='O')
            {
                board[cur.first][cur.second+1] = 'Y';
                q.push(pair<int, int>(cur.first, cur.second+1));
            }
            if(cur.first-1>=0 && board[cur.first-1][cur.second]=='O')
            {
                board[cur.first-1][cur.second] = 'Y';
                q.push(pair<int, int>(cur.first-1, cur.second));
            }
            if(cur.second-1>=0 && board[cur.first][cur.second-1]=='O')
            {
                board[cur.first][cur.second-1] = 'Y';
                q.push(pair<int, int>(cur.first, cur.second-1));
            }
        }
    }
    void solve(vector<vector<char>> &board) {
        if(!board.empty())
        {
            row = board.size();
            col = board[0].size();
            if(row<=2 || col<=2)
                return;
            for(int i = 0; i < row; ++i)
            {
                if(board[i][0]=='O')
                    bfs(i, 0, board);
                if(board[i][col-1]=='O')
                    bfs(i, col-1, board);
            }
            for(int j = 1; j < col - 1; ++j)
            {
                if(board[0][j]=='O')
                    bfs(0, j, board);
                if(board[row-1][j]=='O')
                    bfs(row-1, j, board);
            }
           
            for(int i=0; i<row; ++i)
            {
                for(int j=0; j<col; ++j)
                {
                    if(board[i][j]=='O')
                        board[i][j] = 'X';
                    else if(board[i][j]=='Y')
                        board[i][j] = 'O';
                }
            }
        }
    }
};