JAVA学习-练习试用Java实现“被围绕的区域”

问题：

给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。

示例 1：

输入：board = [["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'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
示例 2：

输入：board = [["X"]]
输出：[["X"]]
提示：

m == board.length
n == board[i].length
1 <= m, n <= 200
board[i][j] 为 'X' 或 'O'

解答思路：

以下是使用 Java 语言解决此问题的步骤：

1. 分析题目
    - 我们需要找到所有被 'X' 围绕的区域，并将这些区域中的 'O' 替换为 'X'。
    - 被围绕的区域是指不在边界上，且与边界上的 'O' 不相连的 'O' 所组成的区域。
    - 我们可以使用深度优先搜索（DFS）或广度优先搜索（BFS）来遍历矩阵，找到被围绕的区域。

2. 选择合适的解法
    - 由于我们需要遍历整个矩阵，并且需要标记已经访问过的元素，因此深度优先搜索是一个合适的选择。

3. 代码实现
    - 以下是使用深度优先搜索解决此问题的 Java 代码：

class Solution {
    public void solve(char[][] board) {
        if (board == null || board.length == 0 || board[0].length == 0) {
            return;
        }

        int rows = board.length;
        int cols = board[0].length;

        // 遍历边界上的 'O'，并将其标记为特殊字符 '#'
        for (int i = 0; i < rows; i++) {
            if (board[i][0] == 'O') {
                dfs(board, i, 0);
            }
            if (board[i][cols - 1] == 'O') {
                dfs(board, i, cols - 1);
            }
        }

        for (int j = 0; j < cols; j++) {
            if (board[0][j] == 'O') {
                dfs(board, 0, j);
            }
            if (board[rows - 1][j] == 'O') {
                dfs(board, rows - 1, j);
            }
        }

        // 将所有未被标记的 'O' 替换为 'X'
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }

        // 将所有标记为 '#' 的元素恢复为 'O'
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (board[i][j] == '#') {
                    board[i][j] = 'O';
                }
            }
        }
    }

    private void dfs(char[][] board, int i, int j) {
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j]!= 'O') {
            return;
        }

        board[i][j] = '#';

        dfs(board, i - 1, j);
        dfs(board, i + 1, j);
        dfs(board, i, j - 1);
        dfs(board, i, j + 1);
    }
}

4. 解释代码
    - 'solve' 方法是主要的函数，它接受一个二维字符矩阵 'board' 作为输入。
    - 首先，它检查矩阵是否为空，如果为空则直接返回。
    - 然后，它使用两个嵌套的循环遍历矩阵的边界。对于每个边界上的 'O'，它调用 'dfs' 方法进行深度优先搜索，并将其标记为特殊字符 '#'。
    - 接下来，它再次遍历矩阵，将所有未被标记的 'O' 替换为 'X'。
    - 最后，它再次遍历矩阵，将所有标记为 '#' 的元素恢复为 'O'。
    - 'dfs' 方法是深度优先搜索的实现。它接受矩阵 'board'、当前行索引 'i' 和当前列索引 'j' 作为输入。
    - 如果当前位置超出矩阵范围或不是 'O'，则直接返回。
    - 否则，它将当前位置标记为 '#'，并递归地调用 'dfs' 方法对其相邻的位置进行搜索。

5. 测试代码
    - 你可以使用以下代码测试上述解决方案：

public class Main {
    public static void main(String[] args) {
        char[][] board = {
                {'X', 'X', 'X', 'X'},
                {'X', 'O', 'O', 'X'},
                {'X', 'X', 'O', 'X'},
                {'X', 'O', 'X', 'X'}
        };

        Solution solution = new Solution();
        solution.solve(board);

        for (char[] row : board) {
            for (char c : row) {
                System.out.print(c + " ");
            }
            System.out.println();
        }
    }
}

6. 最终答案
    - 运行上述代码，将输出：

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

(文章为作者在学习java过程中的一些个人体会总结和借鉴，如有不当、错误的地方，请各位大佬批评指正，定当努力改正，如有侵权请联系作者删帖。)