leetcode-130. 被围绕的区域---广度优先算法与深度优先算法

再次遇到 广度优先算法和深度优先算法。leetcode地址

给定一个二维的矩阵，包含 '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'。如果两个元素在水平或垂直方向相邻，
则称它们是“相连”的。

题目的意思，原来的矩阵由 ‘X’ 和 ‘O’ 组成。这里O有两种类型，

一种是直接或间接与边界相连
一种是完全被‘X’包围

把后者用’X’来替换。

我解题的思路是，先把第一种 ‘O’ 找出来，做个标记，之后遍历一次矩阵，将没有被标记的 ‘O’ 替换为’X’

class Solution {
    int row = 0;
    int col = 0;
    public void solve(char[][] board) {
        if(null == board) return;
        row = board.length;
        if(row == 0) return;
        col = board[0].length;
        if(col == 0) return;
        if(row < 3 || col < 3){ // 行列太少的，不可能会替换，直接返回
            return;
        }
        // 第一行,最后一行包含的O
        for(int i = 0; i < col; i++){
            char firstLine = board[0][i];
            if(firstLine == 'O'){
                board[0][i] = '#';
                deal(0, i, board);
            }
            char lastLine = board[row-1][i];
            if(lastLine == 'O'){
                board[row-1][i] = '#';
                deal(row-1, i, board);
            }
        }
        // 第一列与最后一列
        for(int j = 1; j < row-1; j++){
            char firstCol = board[j][0];
            if(firstCol == 'O'){
                board[j][0] = '#';
                deal(j, 0, board);
            }
            char lastCol = board[j][col -1];
            if(lastCol == 'O'){
                board[j][col -1] = '#';
                deal(j, col-1, board);
            }
        }
        // 把所有的O替换为X,把所有的#替换为O
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(board[i][j] == 'O'){
                    board[i][j] = 'X';
                }
                if(board[i][j] == '#'){
                    board[i][j] = 'O';
                }
            }
        }
    }

    int[] x = new int[]{1, -1, 0, 0};
    int[] y = new int[]{0, 0, 1, -1};
    Queue<Integer> queue = new LinkedList<>();
    
    /*
    * 将传入坐标相连的 O 替换为 #
    */
    private void deal(int r, int c,char[][] board){
        queue.add(r*col + c);  // 原始坐标进入队列
        while(queue.size() > 0){
            int temp = queue.remove();
            for(int i = 0; i < 4; i++){ // 检查其上下左右四个方向的元素
                int rr = x[i] + temp/col;
                int cc = y[i] + temp%col;
                if(rr >= 0 && rr < row && cc >= 0 && cc < col && board[rr][cc] == 'O'){
                    board[rr][cc] = '#';
                    queue.add(rr*col + cc); // 符合条件的坐标入队列，逐步扩散
                }
            }
        }
    }
}

我的解题方法，就是标准的广度优先算法，深度优先算法就用到递归，这里直接把官方题解粘贴出来，有兴趣的可以看一下。

class Solution {
    int n, m;

    public void solve(char[][] board) {
        n = board.length;
        if (n == 0) {
            return;
        }
        m = board[0].length;
        for (int i = 0; i < n; i++) {
            dfs(board, i, 0);
            dfs(board, i, m - 1);
        }
        for (int i = 1; i < m - 1; i++) {
            dfs(board, 0, i);
            dfs(board, n - 1, i);
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'A') {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
    }

    public void dfs(char[][] board, int x, int y) {
        if (x < 0 || x >= n || y < 0 || y >= m || board[x][y] != 'O') {
            return;
        }
        board[x][y] = 'A';
        dfs(board, x + 1, y);
        dfs(board, x - 1, y);
        dfs(board, x, y + 1);
        dfs(board, x, y - 1);
    }
}

在我之前发布的文章中，有个题目和这个题目，思路一样。想要更熟练掌握广度优先算法，深度优先算法的朋友，可以多看一篇——岛屿个数

这两个知识点本身不难理解，练的多了，就掌握，其实就是套路。