C++实现LeetCode(130.包围区域)

[leetcode] 130. surrounded regions 包围区域

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.

这是道关于 xxoo 的题，有点像围棋，将包住的o都变成x，但不同的是边缘的o不算被包围，跟之前那道 number of islands 很类似，都可以用 dfs 来解。刚开始我的思路是 dfs 遍历中间的o，如果没有到达边缘，都变成x，如果到达了边缘，将之前变成x的再变回来。但是这样做非常的不方便，在网上看到大家普遍的做法是扫矩阵的四条边，如果有o，则用 dfs 遍历，将所有连着的o都变成另一个字符，比如 \$，这样剩下的o都是被包围的，然后将这些o变成x，把$变回o就行了。代码如下：

解法一：

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) {
                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) {
        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 > 0 && board[i][j - 1] == 'o') 
                solvedfs(board, i, j - 1);
        }
    }
};

很久以前，上面的代码中最后一个 if 中必须是 j > 1 而不是 j > 0，为啥 j > 0 无法通过 oj 的最后一个大数据集合，博主开始也不知道其中奥秘，直到被另一个网友提醒在本地机子上可以通过最后一个大数据集合，于是博主也写了一个程序来验证，请参见验证 leetcode surrounded regions 包围区域的dfs方法，发现 j > 0 是正确的，可以得到相同的结果。神奇的是，现在用 j > 0  也可以通过 oj 了。

下面这种解法还是 dfs 解法，只是递归函数的写法稍有不同，但是本质上并没有太大的区别，参见代码如下：

解法二：

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);
            }
        }
    }
};

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

解法三：

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) continue;
                if (board[i][j] != 'o') continue;
                board[i][j] = '$';
                queue<int> q{{i * n + j}};
                while (!q.empty()) {
                    int t = q.front(), x = t / n, y = t % n; q.pop();
                    if (x >= 1 && board[x - 1][y] == 'o') {board[x - 1][y] = '$'; q.push(t - n);}
                    if (x < m - 1 && board[x + 1][y] == 'o') {board[x + 1][y] = '$'; q.push(t + n);}
                    if (y >= 1 && board[x][y - 1] == 'o') {board[x][y - 1] = '$'; q.push(t - 1);}
                    if (y < n - 1 && board[x][y + 1] == 'o') {board[x][y + 1] = '$'; q.push(t + 1);}
                }
            }
        }
        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';
            }
        }
    }
};

github 同步地址：

类似题目：

number of islands

walls and gates

参考资料：

https://leetcode.com/problems/surrounded-regions/discuss/41895/share-my-clean-java-code

https://leetcode.com/problems/surrounded-regions/discuss/41825/simple-bfs-solution-easy-to-understand

https://leetcode.com/problems/surrounded-regions/discuss/41612/a-really-simple-and-readable-c%2b%2b-solutionuff0conly-cost-12ms

到此这篇关于c++实现leetcode(130.包围区域)的文章就介绍到这了,更多相关c++实现包围区域内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！