leetcode 130. 被围绕的区域

最新推荐文章于 2022-04-20 13:36:56 发布

原创最新推荐文章于 2022-04-20 13:36:56 发布 · 953 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++

c++ 专栏收录该内容

86 篇文章

订阅专栏

本文介绍了一种利用DFS和BFS解决矩阵中字符替换问题的方法。通过逆向思维，采用DFS进行非递归搜索标记边界相连的'O'字符，并最终实现字符的正确替换。同时对比了DFS和BFS在该问题上的表现差异。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这道题我用的逆向思维法，用DFS判断和边上’O’连接的’O’，然后将他们标记为星号，标记完全部之后，再遍历一次数组，将’O’换为‘X’，’*‘换为O，即可完成。
这个算法可圈点的地方在于，DFS用的是栈实现的，以前实现DFS总是用递归，没想过非递归如何实现，如今又是一个进步。不过我很奇怪为什么我第一次用同样思路，但是用BFS写的算法会超时，有大神帮我看一下吗？
DFS
20ms

struct POS
{
    int x;
    int y;
    POS(int newx, int newy): x(newx), y(newy) {}
};

class Solution {
public:
    void solve(vector<vector<char>> &board) {
        if(board.empty() || board[0].empty())
            return;
        int m = board.size();
        int n = board[0].size();
        for(int i = 0; i < m; i ++)
        {
            for(int j = 0; j < n; j ++)
            {
                if(board[i][j] == 'O')
                {
                    if(i == 0 || i == m-1 || j == 0 || j == n-1)
                    {// remain 'O' on the boundry
                        dfs(board, i, j, m, n);
                    }
                }
            }
        }
        for(int i = 0; i < m; i ++)
        {
            for(int j = 0; j < n; j ++)
            {
                if(board[i][j] == 'O')
                    board[i][j] = 'X';
                else if(board[i][j] == '*')
                    board[i][j] = 'O';
            }
        }
    }
    void dfs(vector<vector<char>> &board, int i, int j, int m, int n)
    {
        stack<POS*> stk;
        POS* pos = new POS(i, j);
        stk.push(pos);
        board[i][j] = '*';
        while(!stk.empty())
        {
            POS* top = stk.top();
            if(top->x > 0 && board[top->x-1][top->y] == 'O')
            {
                POS* up = new POS(top->x-1, top->y);
                stk.push(up);
                board[up->x][up->y] = '*';
                continue;
            }
            if(top->x < m-1 && board[top->x+1][top->y] == 'O')
            {
                POS* down = new POS(top->x+1, top->y);
                stk.push(down);
                board[down->x][down->y] = '*';
                continue;
            }
            if(top->y > 0 && board[top->x][top->y-1] == 'O')
            {
                POS* left = new POS(top->x, top->y-1);
                stk.push(left);
                board[left->x][left->y] = '*';
                continue;
            }
            if(top->y < n-1 && board[top->x][top->y+1] == 'O')
            {
                POS* right = new POS(top->x, top->y+1);
                stk.push(right);
                board[right->x][right->y] = '*';
                continue;
            }
            stk.pop();
        }
    }
};

BFS
TLE

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        int m = board.size();
        if (m == 0)
            return;
        int n = board[0].size();
        for (int i = 0; i<n; ++i) {
            if (board[0][i] == 'O') {
                process(board, 0, i);
            }
            if (board[m - 1][i] == 'O') {
                process(board, m - 1, i);
            }
        }
        for (int i = 1; i<m - 1; ++i) {
            if (board[i][0] == 'O') {
                process(board, i, 0);
            }
            if (board[i][n - 1] == 'O') {
                process(board, i, n - 1);
            }
        }
        for (auto &k : board) {
            for (auto &t : k) {
                if (t == 'Z')
                    t = 'O';
                else if (t == 'O')
                    t = 'X';
            }
        }
        return;
    }
    void process(vector<vector<char>>& board, int p, int q) {
        vector<int>xaxi{ 1,-1,0,0 };
        vector<int>yaxi{ 0,0,1,-1 };
        deque<pair<int, int>>cur;
        deque<pair<int, int>>next;
        cur.push_back({ p,q });
        while (!cur.empty()) {
            auto tmp = cur.front();
            cur.pop_front();
            board[tmp.first][tmp.second] = 'Z';
            for (int i = 0; i<4; ++i) {
                int x = tmp.first + xaxi[i];
                int y = tmp.second + yaxi[i];
                if (x >= 0 && x<board.size() && y >= 0 && y<board[0].size()) {
                    if (board[x][y] == 'O') {
                        next.push_back({ x,y });
                    }
                }
            }
            if (cur.empty()) {
                swap(cur, next);
            }
        }
    }
};