LeetCode 力扣 6130. 被围绕的区域 Surrounded Regions

大家觉得写还可以，可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn

---

130. 被围绕的区域

题目描述

给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。

找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例:

X X X X
X O O X
X X O X
X O X X
运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X

解释:

被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

分析

其实关于这种迷宫题，做多了一眼就知道是从边界进行搜索连通块，剩下的未联通的O则肯定是被X所包围，如果对于新手来说，啊哈算法里面的解法确实挺有趣的，有兴趣大家也可以去搜搜电子书看一下关于它里面所讲的岛屿问题，不亏哈哈哈

---

• 根据“解释”，我们很容易想到：任何与边界上的’O’直接或间接相连的’O’都不会被填充’X’，那么我们朴素的想法就是遍历边界找到上面所有的’O’，对边界上的每一个’O’，标记它并且标记与它直接或间接相连的’O’.

• 当标记完后，再一次遍历整个矩阵，

• 如果是’X’，直接跳过。

• 如果是’O’，检查它是否被标记，是则说明它不应该被填充，跳过；否则填充。

• 现在关键是怎么实现标记

• 深度优先搜索：对边界上的’O’进行DFS，如果它四个方向上有’O’标记并继续从这个’O’开始进行DFS直至越界。

• 广度优先搜索：借助队列，把边界上的’O’标记后全部入队。每次取出一个，并将其四周的’O’标记后入队（为什么先标记后入队？答：避免同一个’O’重复入队）。循环执行直至队列为空。

BFS代码

class Solution {
    int m = 0;  // 行数
    int n = 0;  // 列数
    // 用作控制4个方向
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};
    public void solve(char[][] board) {
        // java二维矩阵的行数和列数可能不同，并且每一行的列数可能都不一样
        // 但是肯定是先后行再有列，而且根据题目要求，在这里每一行的列数都是相同的
        m = board.length;       //  行数m
        if (m == 0) {   // 行数为0，board为空
            return;
        }
        n = board[0].length;    // 列数
        Queue<int[]> queue = new LinkedList<int[]>();
        // 搜索上下边界，先标记后入队
        for (int i = 0; i < n; i++) {
            if (board[0][i] == 'O') {   //  第一行
                board[0][i] = 'M';
                queue.offer(new int[]{0, i});
            }
            if (board[m - 1][i] == 'O') {      // 最后一行
                board[m - 1][i] = 'M';
                queue.offer(new int[]{m - 1, i});
            }
        }
        // 搜索左右边界，先标记后入队
        for (int i = 1; i < m - 1; i++) {
            if (board[i][0] == 'O') {   // 第一列
                board[i][0] = 'M';
                queue.offer(new int[]{i, 0});
            }
            if (board[i][n - 1] == 'O') {   // 最后一列
                board[i][n - 1] = 'M';
                queue.offer(new int[]{i, n - 1});
            }
        }
        // 广度优先搜索
        while (!queue.isEmpty()) {
            int[] temp = queue.poll();
            int x = temp[0], y = temp[1];   // 获取行和列
            for (int i = 0; i < 4; i++) {   // 搜索四个方向
                int mx = x + dx[i], my = y + dy[i]; 
                if (mx < 0 || mx >= m || my < 0 || my >= n) {     // 越界
                    continue;
                } else if (board[mx][my] == 'O') {  // 搜索到了'O'，标记后入队
                    board[mx][my] = 'M';
                    queue.offer(new int[]{mx, my});
                }
            }
        }
        // 标记完，再次遍历，现在矩阵中可能有3中字符，'X','M','O'
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 'X') {
                    continue;
                } else if (board[i][j] == 'O'){ // 出现没被标记过的'O'，应该被填充
                    board[i][j] = 'X';
                } else if (board[i][j] == 'M'){ // 被标记过的，不应该被填充，恢复
                    board[i][j] = 'O';
                }
            }
        }
    }
}

DFS代码

class Solution {
    int m = 0;  // 行数
    int n = 0;  // 列数
    public void solve(char[][] board) {
        // java二维矩阵的行数和列数可能不同，并且每一行的列数可能都不一样
        // 但是肯定是先后行再有列，而且根据题目要求，在这里每一行的列数都是相同的
        m = board.length;       //  行数m
        if (m == 0) {   // 行数为0，board为空
            return;
        }
        n = board[0].length;    // 列数
        // 搜索上下边界的'O'
        for (int i = 0; i < n; i++) {
            if (board[0][i] == 'O') {   //  第一行
                DFS(board, 0, i);   // 标记
            }
            if (board[m - 1][i] == 'O') {      // 最后一行
                DFS(board, m - 1, i);   // 标记
            }
        }
        // 搜索左右边界
        for (int i = 1; i < m - 1; i++) {
            if (board[i][0] == 'O') {   // 第一列
                DFS(board, i, 0);       // 标记
            }
            if (board[i][n - 1] == 'O') {   // 最后一列
                DFS(board, i, n - 1);   // 标记
            }
        }
        // 标记完，再次遍历，现在矩阵中可能有3中字符，'X','M','O'
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 'X') {   
                    continue;
                } else if (board[i][j] == 'O'){ // 出现没被标记过的'O'，应该被填充
                    board[i][j] = 'X';
                } else if (board[i][j] == 'M'){ // 被标记过的，不应该被填充，恢复
                    board[i][j] = 'O';
                }
            }
        }
    }

    public void DFS(char[][] board, int x, int y) {
        // 越界或者不是字符'O'终止
        if (x < 0 || x >= m || y < 0 || y >= n || board[x][y] != 'O') {
            return;
        }
        board[x][y] = 'M';  // 修改为'M'表示这个字符被标记了
        // 搜索四个方向
        DFS(board, x - 1, y);   // 上
        DFS(board, x + 1, y);   // 下
        DFS(board, x, y - 1);   // 左
        DFS(board, x, y + 1);   // 右
    }
}

提交结果对比

---

2020年8月11日更

大家觉得写还可以，可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn

---