[算法基础] FooldFill（DFS、BFS）

695. 岛屿的最大面积 - 力扣（LeetCode）

DFS 完整代码：

class Solution {
    int[][] grid;
    int rows;
    int columns;
    int area;

    public int maxAreaOfIsland(int[][] grid) {
        this.grid = grid;
        rows = grid.length;
        columns = grid[0].length;

        int maxArea = 0;

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                if (grid[i][j] == 1) {
                    dfs(i, j);
                    maxArea = Math.max(maxArea, area);
                    area = 0;
                }
            }
        }

        return maxArea;
    }

    private void dfs(int r, int c) {
        if (r < 0 || r >= rows || c < 0 || c >= columns
                || grid[r][c] != 1) {
            return;
        }

        grid[r][c] = 2;
        area++;

        dfs(r - 1, c);
        dfs(r + 1, c);
        dfs(r, c - 1);
        dfs(r, c + 1);
    }
}

BFS 完整代码：

class Solution {
    int[][] grid;
    int rows;
    int columns;

    static class Pair {
        int row;
        int column;

        public Pair(int row, int column) {
            this.row = row;
            this.column = column;
        }
    }

    public int maxAreaOfIsland(int[][] grid) {
        this.grid = grid;
        rows = grid.length;
        columns = grid[0].length;

        int ret = 0;

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                if (grid[i][j] == 1) {
                    int area = bfs(new Pair(i, j));
                    ret = Math.max(ret, area);
                }
            }
        }

        return ret;
    }

    public int bfs(Pair pair) {
        int ret = 0;
        Queue<Pair> queue = new LinkedList<>();
        queue.add(pair);

        while (!queue.isEmpty()) {
            Pair temp = queue.poll();
            int r = temp.row;
            int c = temp.column;

            if (r < 0 || r >= rows || c < 0 || c >= columns
                    || grid[r][c] != 1) {
                continue;
            }

            grid[r][c] = 2;
            ret++;

            queue.add(new Pair(r - 1, c));
            queue.add(new Pair(r + 1, c));
            queue.add(new Pair(r, c - 1));
            queue.add(new Pair(r, c + 1));
        }

        return ret;
    }
}

---

130. 被围绕的区域 - 力扣（LeetCode）

正难则反。这道题要找所有被围绕的 O 区域，不太好找，因此我们可以先找那些不被围绕的 O 区域，这些区域是好找的，因为它们一定至少有一个坐标是位于矩阵边缘的。现在我们仅需探测矩阵的边缘即可，碰到 O 就 DFS 进去。

class Solution {
    char[][] board;
    int rows;
    int columns;
    boolean[][] notSurrounded; // 记录所有不被围绕的区域为 true

    public void solve(char[][] board) {
        this.board = board;
        rows = board.length;
        columns = board[0].length;
        this.notSurrounded = new boolean[rows][columns];

        // 找上边缘和下边缘
        for (int i = 0; i < rows; i++) {
            if (board[i][0] == 'O') {
                dfs(i, 0);
            }
            if (board[i][columns - 1] == 'O') {
                dfs(i, columns - 1);
            }
        }

        // 找左边缘和右边缘
        for (int j = 1; j < columns - 1; j++) {
            if (board[0][j] == 'O') {
                dfs(0, j);
            }
            if (board[rows - 1][j] == 'O') {
                dfs(rows - 1, j);
            }
        }

        // 再次遍历，找被围绕区域
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                if (board[i][j] == 'O' && !notSurrounded[i][j]) {
                    board[i][j] = 'X';
                }
            }
        }
    }

    private void dfs(int r, int c) {
        // 坐标越界 || 不是 O || 该坐标已经走过
        if (r < 0 || r >= rows || c < 0 || c >= columns
                || board[r][c] != 'O' || notSurrounded[r][c]) {
            return;
        }

        notSurrounded[r][c] = true;

        dfs(r - 1, c);
        dfs(r + 1, c);
        dfs(r, c - 1);
        dfs(r, c + 1);
    }
}