LeetCode OJ-- Surrounded Regions **@

https://oj.leetcode.com/problems/surrounded-regions/

棋盘类的题目。找出所有没有被 X 包围的 O

使用深搜，但是太深了，run time error

可以自己写个栈，模拟深搜，取数据存入，弹出的

后来参考了九章

struct point{
        int x;
        int y;
        point(int x, int y)
        {
            this->x = x;
            this->y = y;
        }
    };

class Solution {
public:
    queue<point> myQueue;
    int row;
    int col;

    void solve(vector<vector<char>> &board) {
        if(board.empty() || board.size() ==  || board[].size() == )
            return;

        row = board.size();
        col = board[].size();

        // push 边上的 O in queue
        for(int i = ; i < row; i++)
        {
            if(board[i][] == 'O')
                myQueue.push(point(i,));
            if(col >=  && board[i][col - ] == 'O')
                myQueue.push(point(i,col-));
        }
        for(int j = ; j< col; j++)
        {
            if(board[][j] == 'O')
                myQueue.push(point(,j));
            if(board[row-][j] == 'O')
                myQueue.push(point(row-,j));
        }
        point tempPoint(,);
        // 对queue中的每一个位置，处理它的上下左右
        while(myQueue.empty() == false)
        {
            tempPoint = myQueue.front();
            myQueue.pop();
            int x = tempPoint.x;
            int y = tempPoint.y;

            board[x][y] = 'K';  // mark as K, which can't be chagned into X in the end
            //left
            if(y >=  && board[x][y-] == 'O')
                myQueue.push(point(x,y-));
            //right
            if(y+ < col && board[x][y+] == 'O')
                myQueue.push(point(x,y+));
            //up
            if(x- >=  && board[x-][y] == 'O')
                myQueue.push(point(x-,y));
            //down
            if(x+ < row && board[x+][y] == 'O')
                myQueue.push(point(x+,y));
        }

        for(int i = ; i < row; i++)
            for(int j = ; j < col; j++)
            {
                if(board[i][j] == 'O')
                    board[i][j] = 'X';
                else if(board[i][j] == 'K')
                    board[i][j] = 'O';
            }
        return;
    }

};
 

下面是我的解法，但是测试数据大的时候过不去。。。

class Solution {
public:
    vector<vector<bool> > isSafe;
    vector<vector<char> > board;
    vector<vector<bool> > visited;

    void solve(vector<vector<char>> &board) {
        if(board.empty() || board.size() ==  || board[].size() == )
            return;

        this->board = board;

        isSafe.resize(board.size());
        visited.resize(board.size());

        // init
        for(int i = ; i < board.size(); i++)
        {
            isSafe[i].resize(board[].size());
            visited[i].resize(board[].size());

            for(int j = ; j < board[].size(); j++)
            {
                isSafe[i][j] = true;
                if(board[i][j] == 'X')
                    visited[i][j] = true;
                else
                    visited[i][j] = false;
            }
        }

        for(int i = ;  i < board.size(); i++)
            for(int j = ; j < board[].size(); j++)
            {
                if(!visited[i][j])
                    isSurround(i,j);
            }

        //isSurround(0,0);

        for(int i = ; i < board.size(); i++)
            for(int j = ; j < board[].size(); j++)
                if(isSafe[i][j])
                    board[i][j] = 'X';

        return;
    }

    void isSurround(int i, int j)
    {
        if(i == board.size())
            return;

        // handle 边
        if(board[i][j] == 'O' && (i ==  || i == board.size() -  || j ==  || j == board[].size() - ))
        {
            isSafe[i][j] = false;
            visited[i][j] = true;
        }

        if(isSafe[i][j] == false)
        {
            // mark right and down
            for(int p = j + ; p < board[].size(); p++)
            {
                if(board[i][p] == 'O')
                {
                    isSafe[i][p] = false;
                    visited[i][p] = true;
                }
                else
                    break;
            }
            for(int q = i + ; q < board.size(); q++)
            {
                if(board[q][j] == 'O')
                {
                    isSafe[q][j] = false;
                    visited[q][j] = true;
                }
                else
                    break;
            }
        }
        else if(board[i][j] == 'O')
        {
             visited[i][j] = true;

            // left
            if(j >  && board[i][j-] == 'O' && !visited[i][j-])
                isSurround(i,j-);
            if(j >  && isSafe[i][j-] == false)
            {
                isSafe[i][j] = false;
                return;
            }
            // up
            if(i >  && board[i-][j] == 'O' && !visited[i-][j])
                isSurround(i-,j);
            if(i >  && isSafe[i-][j] == false)
            {
                isSafe[i][j] = false;
                return;
            }

            // right is O
            if((j < board[].size() - ) &&board[i][j+] == 'O' && !visited[i][j+])
               isSurround(i,j+);
             if((j < board[].size() - ) && isSafe[i][j+] == false)
             {
                 isSafe[i][j] = false;
                 return;
             }
            // down is O
            if((i < board.size() - ) && board[i+][j] == 'O' && !visited[i+][j])
                isSurround(i+,j);
            if((j < board.size() - ) && isSafe[i+][j] == false)
             {
                 isSafe[i][j] = false;
                 return;
             }

             visited[i][j] = true;
        }

    }

};