Surrounded Regions --leetcode

最新推荐文章于 2019-09-22 20:49:08 发布

原创最新推荐文章于 2019-09-22 20:49:08 发布 · 549 阅读

0 ·

CC 4.0 BY-SA版权

算法题目专栏收录该内容

4 篇文章

订阅专栏

本文将详细解析如何解决LeetCode中的'surrounded regions'问题，通过使用广度优先搜索（BFS）算法，有效地处理棋盘上的'O'元素，确保所有被'X'包围的'O'都被转换为'X'，同时保留边界'O'的原始状态。

题目：

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

思路：如果一个棋子O不会被改变，那么一定有与之相连的O在四条边上。因此可以利用flood fill算法对四条边上的O进行处理，先将O改成其他的字母，这样就不需要记录已经访问过的点了。这个题目leetcode 里面如果利用DFS递归算法的话，会出现runtime error，应该是对于函数的递归调用有限制，因此改为BFS就可以了。

class Solution {
public:
  struct point{
        int x;
        int y;
    };
   void solve(vector<vector<char> > &board)
    {
        int isx = board.size();
        if(isx <=0 )return ;
        int isy = board[0].size();
        for (int i =0; i < isy; i ++)
        {
            presolve(board,0,i);
            presolve(board,isx-1,i);
        }

        for (int i =1; i < isx; i ++)
        {
            presolve(board,i,0);
            presolve(board,i,isy-1);
        }

        for (int i =0;i < isx;i ++)
        {
            for (int j = 0;j < isy;j ++)
            {
                if(board[i][j] == 'O')
                {
                    board[i][j] = 'X';
                }
                else if(board[i][j] == 't')
                {
                     board[i][j] = 'O';
                }

            }
        }
    }
    //use BFS DFS will run error
    void presolve(vector<vector<char> > &board,int x,int y)
    {
        if(board[x][y] != 'O') return ;
        queue<point> pq;
        point pt;
        pt.x = x;
        pt.y = y;
        pq.push(pt);
        point tp;
        while (!pq.empty())
        {
            tp = pq.front();
            pq.pop();
            if(board[tp.x][tp.y] == 'O')
            {
                board[tp.x][tp.y] = 't';
            if(tp.x-1 >= 0 && board[tp.x-1][tp.y] == 'O')
            {
                pt.x = tp.x-1;
                pt.y = tp.y;
                pq.push(pt);
            }
            if(tp.x+1 < board.size() && board[tp.x+1][tp.y] == 'O')
            {
                pt.x = tp.x+1;
                pt.y = tp.y;
                pq.push(pt);
            }
             if(tp.y-1 >= 0 && board[tp.x][tp.y-1] == 'O')
            {
                pt.x = tp.x;
                pt.y = tp.y-1;
                pq.push(pt);
            }
            if(tp.y+1 >= 0 && board[tp.x][tp.y+1] == 'O')
            {
                pt.x = tp.x;
                pt.y = tp.y+1;
                pq.push(pt);
            }
            }
            
        }
        return ;
    }
};