[Leetcode][第130题][JAVA][被围绕的区域][DFS][BFS]

最新推荐文章于 2023-01-28 15:14:00 发布

CryptWinter

最新推荐文章于 2023-01-28 15:14:00 发布

阅读量292

点赞数

分类专栏：刷题非0即1 文章标签： leetcode dfs bfs JAVA

原文链接：https://leetcode-cn.com/problems/surrounded-regions/solution/bei-wei-rao-de-qu-yu-by-leetcode-solution/

版权

刷题同时被 2 个专栏收录

249 篇文章 2 订阅

订阅专栏

非0即1

239 篇文章 1 订阅

订阅专栏

本文探讨了在解决被围攻区域问题时，深度优先搜索（DFS）和广度优先搜索（BFS）两种算法的应用。通过具体代码示例，详细解释了如何在二维矩阵中对特定字符进行标记，避免被替换。文章强调了方向定义和边界判断的重要性，并提供了清晰的步骤说明。

摘要由CSDN通过智能技术生成

【问题描述】[中等]

在这里插入图片描述

【解答思路】

在这里插入图片描述

1. 深度优先搜索

使用深度优先搜索实现标记操作。在下面的代码中，我们把标记过的字母 O 修改为字母 A。
复杂度
在这里插入图片描述

class Solution {
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};

    public void solve(char[][] board) {
        int n = board.length;
        if (n == 0) {
            return;
        }
        int m = board[0].length;
        Queue<int[]> queue = new LinkedList<int[]>();
        for (int i = 0; i < n; i++) {
            if (board[i][0] == 'O') {
                queue.offer(new int[]{i, 0});
            }
            if (board[i][m - 1] == 'O') {
                queue.offer(new int[]{i, m - 1});
            }
        }
        for (int i = 1; i < m - 1; i++) {
            if (board[0][i] == 'O') {
                queue.offer(new int[]{0, i});
            }
            if (board[n - 1][i] == 'O') {
                queue.offer(new int[]{n - 1, i});
            }
        }
        while (!queue.isEmpty()) {
            int[] cell = queue.poll();
            int x = cell[0], y = cell[1];
            board[x][y] = 'A';
            for (int i = 0; i < 4; i++) {
                int mx = x + dx[i], my = y + dy[i];
                if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != 'O') {
                    continue;
                }
                queue.offer(new int[]{mx, my});
            }
        }
        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';
                }
            }
        }
    }
}

2. 广度优先搜索

以使用广度优先搜索实现标记操作。在下面的代码中，我们把标记过的字母 O 修改为字母 A
时间复杂度：O(N) 空间复杂度：O(1)

class Solution {
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};

    public void solve(char[][] board) {
        int n = board.length;
        if (n == 0) {
            return;
        }
        int m = board[0].length;
        Queue<int[]> queue = new LinkedList<int[]>();
        for (int i = 0; i < n; i++) {
            if (board[i][0] == 'O') {
                queue.offer(new int[]{i, 0});
            }
            if (board[i][m - 1] == 'O') {
                queue.offer(new int[]{i, m - 1});
            }
        }
        for (int i = 1; i < m - 1; i++) {
            if (board[0][i] == 'O') {
                queue.offer(new int[]{0, i});
            }
            if (board[n - 1][i] == 'O') {
                queue.offer(new int[]{n - 1, i});
            }
        }
        while (!queue.isEmpty()) {
            int[] cell = queue.poll();
            int x = cell[0], y = cell[1];
            board[x][y] = 'A';
            for (int i = 0; i < 4; i++) {
                int mx = x + dx[i], my = y + dy[i];
                if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != 'O') {
                    continue;
                }
                queue.offer(new int[]{mx, my});
            }
        }
        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';
                }
            }
        }
    }
}

【总结】

1. 细节：

1.1 方向定义
int[] dx = {1, -1, 0, 0};
int[] dy = {0, 0, 1, -1};
1.2 边界判断
if (mx < 0 || my < 0 || mx >= n || my >= m || board[mx][my] != ‘O’) {
continue;
}

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。