130. Surrounded Regions

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

原创最新推荐文章于 2024-01-21 17:09:59 发布 · 271 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #bfs #dfs

本文详细介绍了如何使用深度优先搜索(DFS)和广度优先搜索(BFS)解决二维矩阵中被‘X’包围的‘O’区域问题。通过将边界上的‘O’及其相连的‘O’标记为特殊符号，再将剩余的‘O’转换为‘X’，最后恢复边界‘O’区域，实现了对被包围区域的捕获。

130. Surrounded Regions

方法1: DFS
方法2: BFS

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.

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

Explanation:

Surrounded regions shouldn’t be on the border, which means that any ‘O’ on the border of the board are not flipped to ‘X’. Any ‘O’ that is not on the border and it is not connected to an ‘O’ on the border will be flipped to ‘X’. Two cells are connected if they are adjacent cells connected horizontally or vertically.

https://www.cnblogs.com/higerzhang/p/4149040.html

思路：
http://www.cnblogs.com/grandyang/p/4555831.html
Explanation当中透露了思路。我们的目标是找到所有与某一个在边界的’O’相连的‘O’，可以用dfs或者bfs来做。dfs容易造成栈溢出，需要限定搜索的边界来避免。

方法1: DFS

class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.size() == 0 || board[0].size() == 0) 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 ((i == 0 || i == board.size() - 1||j ==0 || j == board[0].size() - 1) &&  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';
            }
        }
        return;
        
    }
    
    void dfs(vector<vector<char>> & board, int i, int j){
        if (board[i][j] == 'O'){
            int m = board.size();
            int n = board[0].size();
            board[i][j] = '$';
        
        if (i > 0 && board[i - 1][j] == 'O'){
            dfs(board, i - 1, j);
        }
        
        if (i < m - 1 && board[i + 1][j] == 'O'){
            dfs(board, i + 1, j);
        }
        
        if (j > 0 && board[i][j - 1] == 'O'){
            dfs(board, i, j - 1);
        }
        
        if (j < n - 1 && board[i][j + 1] == 'O'){
            dfs(board, i, j + 1);
        }
        return;
        }
    }
};

方法2: BFS

我们也可以使用迭代的解法，但是整体的思路还是一样的，我们在找到边界上的O后，然后利用队列queue进行BFS查找和其相连的所有O，然后都标记上美元号。最后的处理还是先把所有的O变成X，然后再把美元号变回O即可，参见代码如下：


class Solution {
public:
    void solve(vector<vector<char>>& board) {
        if (board.size() == 0 || board[0].size() == 0) return;
        int m = board.size();
        int n = board[0].size();
        
        queue<pair<int, int>> myQueue;
        
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++)
                if ((i == 0 || i == board.size() - 1||j ==0 || j == board[0].size() - 1) &&  board[i][j] == 'O'){
                    myQueue.push(make_pair(i, j));
                }          
        }
        
        // call bfs
        bfs(board, myQueue);
        
        // final flip
        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';
            }
        }
        return;
    }
    
    void bfs(vector<vector<char>> & board, queue<pair<int, int>> & q){
        int m = board.size();
        int n = board[0].size();
        
        while (!q.empty()){
            int i = q.front().first;
            int j = q.front().second;
            q.pop();
           
            board[i][j] = '$';
            if (i > 0 && board[i - 1][j] == 'O'){
               q.push(make_pair(i - 1, j));
             }
        
        if (i < m - 1 && board[i + 1][j] == 'O'){
           q.push(make_pair(i + 1, j));
        }
        
        if (j > 0 && board[i][j - 1] == 'O'){
            q.push(make_pair(i, j - 1));
        }
        
        if (j < n - 1 && board[i][j + 1] == 'O'){
           q.push(make_pair(i, j + 1));
        }
        }
        return;
    }
};