130. Surrounded Regions

最新推荐文章于 2024-01-21 17:09:59 发布

StudyCoder

最新推荐文章于 2024-01-21 17:09:59 发布

阅读量355

点赞数

分类专栏： leetcode整理 Breadt-first Search

leetcode整理 Breadt-first Search 专栏收录该内容

6 篇文章

订阅专栏

本文介绍了一种名为“包围区域”的算法问题，通过深度优先搜索（DFS）和广度优先搜索（BFS）两种方法实现解决方案。针对二维板上由‘X’字符包围的‘O’字符区域，将其转化为‘X’字符，而边缘相连的‘O’字符则保持不变。

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

题目：包围区域

Given a 2D board containing 'X' and 'O' (the letter 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’字符包围起来的区域就叫做一个区域被捕获。

思路一：

DFS解决。这道题有点像围棋，将包住的O都变成X，但不同的是边缘的O不算被包围，跟之前那道Number of Islands 岛屿的数量很类似，都可以用DFS来解。扫面矩阵的四条边，如果有O，则用DFS遍历，将所有连着的O都变成另一个字符。完成遍历，将剩下的‘O’都是被包围的，都变成‘X’字符，如果为‘$’字符的，说明是没有被包围住的，所以还原成‘O’字符。

代码：C++版：16ms

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        for (int i=0; i<board.size(); ++i) {
            for (int j=0; j<board[i].size(); ++j) {
                //核心控制，从二维板的四周开始向中心搜索，连在一起的‘O’字符都是没被包围的
                if ((i==0 || i==board.size()-1 || j==0 || j==board[i].size()-1) && board[i][j]=='O')
                    solveDFS(board, i, j);
            }
        }
        for (int i=0; i<board.size(); ++i) { //遍历结束，处理原二维板
            for (int j=0; j<board[i].size(); ++j) {
                if (board[i][j] == 'O') board[i][j] = 'X';
                if (board[i][j] == '$') board[i][j] = 'O';
            }
        }
    }
    void solveDFS(vector<vector<char>> &board, int i, int j) { //搜寻连在一起的‘O’字符
        if (board[i][j] == 'O') {
            board[i][j] = '$';
            if (i>0 && board[i-1][j] == 'O')
                solveDFS(board, i-1, j);
            if (j<board[i].size()-1 && board[i][j+1] == 'O')
                solveDFS(board, i, j+1);
            if (i<board.size()-1 && board[i+1][j] == 'O')
                solveDFS(board, i+1, j);
            if (j>1 && board[i][j-1] == 'O')
                solveDFS(board, i, j-1);
        }
    }
};

另一种写法，主要思路相同，只是DFS的递归实现方式不是太相同，使用了一些小技巧。

代码：C++版：92ms

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.empty() || board[0].empty()) return;
        int m = board.size(), n = board[0].size();
        for (int i=0; i<m; ++i) {
            for (int j=0; j<n; ++j) {
                if (i==0 || i==m-1 || j==0 || j==n-1) {
                    if (board[i][j] == 'O')
                        dfs(board, i, j);
                }
            }
        }
        for (int i=0; i<m; ++i) {
            for (int j=0; j<n; ++j) {
                if (board[i][j] == 'O') board[i][j] = 'X';
                if (board[i][j] == '$') board[i][j] = 'O';
            }
        }
    }
    void dfs(vector<vector<char>> &board, int x, int y) { //主要是这里的实现不一样
        int m = board.size(), n = board[0].size();
        vector<vector<int>> dir{{0, -1}, {-1,0}, {0,1}, {1,0}};
        board[x][y] = '$';
        for (int i=0; i<dir.size(); ++i) {
            int dx = x+dir[i][0], dy = y+dir[i][1];
            if (dx>=0 && dx<m && dy>0 && dy<n && board[dx][dy]=='O')
                dfs(board, dx, dy);
        }
    }
};

思路二：

BFS实现广搜。从上下左右四个边界往里走，凡是能碰到的'O'，都是跟边界接壤的，应该保留。

代码：C++版：32ms

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.empty()) return;
        const int m = board.size();
        const int n = board[0].size();
        for (int i=0; i<n; i++) {
            bfs(board, 0, i);
            bfs(board, m-1, i);
        }
        for (int j=1; j<m-1; j++) {
            bfs(board, j, 0);
            bfs(board, j, n-1);
        }
        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';
            }
        }
    }
private:
    void bfs(vector<vector<char>> &board, int i, int j) {
        typedef pair<int, int> state_t;
        queue<state_t> q;
        const int m = board.size();
        const int n = board[0].size();
        
        auto is_valid = [&](const state_t &s) {
            const int x = s.first;
            const int y = s.second;
            if (x<0 || x>=m || y<0 || y>=n || board[x][y]!='O')
                return false;
            return true;
        };
        auto state_extend = [&](const state_t &s) {
            vector<state_t> res;
            const int x = s.first;
            const int y = s.second;
            //上下左右
            const state_t new_states[4] = {{x-1,y}, {x+1,y}, {x,y-1}, {x,y+1}};
            for (int k=0; k<4; ++k) {
                if (is_valid(new_states[k])) {
                    //既有标记功能又有去重功能
                    board[new_states[k].first][new_states[k].second] = '+';
                    res.push_back(new_states[k]);
                }
            }
            return res;
        };
        state_t start = {i,j};
        if (is_valid(start)) {
            board[i][j] = '+';
            q.push(start);
        }
        while (!q.empty()) {
            auto cur = q.front();
            q.pop();
            auto new_states = state_extend(cur);
            for (auto s : new_states)
                q.push(s);
        }
    }
};