[LeetCode] 1905. Count Sub Islands

You are given two m x n binary matrices grid1 and grid2 containing only 0's (representing water) and 1's (representing land). An island is a group of 1's connected 4-directionally (horizontal or vertical). Any cells outside of the grid are considered water cells.

An island in grid2 is considered a sub-island if there is an island in grid1 that contains all the cells that make up this island in grid2.

Return the number of islands in grid2 that are considered sub-islands.

Example 1:

Input: grid1 = [[1,1,1,0,0],[0,1,1,1,1],[0,0,0,0,0],[1,0,0,0,0],[1,1,0,1,1]], grid2 = [[1,1,1,0,0],[0,0,1,1,1],[0,1,0,0,0],[1,0,1,1,0],[0,1,0,1,0]]
Output: 3
Explanation: In the picture above, the grid on the left is grid1 and the grid on the right is grid2.
The 1s colored red in grid2 are those considered to be part of a sub-island. There are three sub-islands.

Example 2:

Input: grid1 = [[1,0,1,0,1],[1,1,1,1,1],[0,0,0,0,0],[1,1,1,1,1],[1,0,1,0,1]], grid2 = [[0,0,0,0,0],[1,1,1,1,1],[0,1,0,1,0],[0,1,0,1,0],[1,0,0,0,1]]
Output: 2 
Explanation: In the picture above, the grid on the left is grid1 and the grid on the right is grid2.
The 1s colored red in grid2 are those considered to be part of a sub-island. There are two sub-islands.

Constraints:

• m == grid1.length == grid2.length
• n == grid1[i].length == grid2[i].length
• 1 <= m, n <= 500
• grid1[i][j] and grid2[i][j] are either 0 or 1.

统计子岛屿。

给你两个 m x n 的二进制矩阵 grid1 和 grid2 ，它们只包含 0 （表示水域）和 1 （表示陆地）。一个 岛屿 是由 四个方向 （水平或者竖直）上相邻的 1 组成的区域。任何矩阵以外的区域都视为水域。

如果 grid2 的一个岛屿，被 grid1 的一个岛屿 完全 包含，也就是说 grid2 中该岛屿的每一个格子都被 grid1 中同一个岛屿完全包含，那么我们称 grid2 中的这个岛屿为 子岛屿 。

请你返回 grid2 中 子岛屿 的 数目 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-sub-islands
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这是一道典型的flood fill类型的题，做法也类似于200题。我给出 DFS 和 BFS 的思路。

题目问的是两个尺寸相同的矩阵 grid1 和 grid2，在 grid2 中出现的岛屿是否能被 grid1 中同一个岛屿完全包含。按照这个题意，我们先去 grid2 里找一个岛屿的起点，在将当前这个岛的尺寸扩张的同时，我们需要判断在 grid2 里是岛屿的坐标，在 grid1 里是否也是岛屿，如果不是则返回 false。只有 grid2 的当前岛屿可以完全被 grid1 覆盖，才是子岛屿。

DFS

时间O(mn)

空间O(mn) - 递归的栈空间

Java实现

class Solution {
    int[][] dirs = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
    int rows;
    int cols;
    int[][] grid1;
    int[][] grid2;

    public int countSubIslands(int[][] grid1, int[][] grid2) {
        rows = grid2.length;
        cols = grid2[0].length;
        this.grid1 = grid1;
        this.grid2 = grid2;
        int count = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid2[i][j] == 1 && dfs(i, j)) {
                    count++;
                }
            }
        }
        return count;
    }

    private boolean dfs(int i, int j) {
        boolean flag = true;
        grid2[i][j] = 0;
        if (grid1[i][j] != 1) {
            flag = false;
        }
        for (int[] d : dirs) {
            int newX = i + d[0];
            int newY = j + d[1];
            if (newX >= 0 && newX < rows && newY >= 0 && newY < cols && grid2[newX][newY] == 1) {
                if (!dfs(newX, newY)) {
                    flag = false;
                }
            }
        }
        return flag;
    }
}

BFS

时间O(mn)

空间O(mn) - 递归的栈空间

Java实现

class Solution {
    int[][] dirs = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
    int rows;
    int cols;
    int[][] grid1;
    int[][] grid2;

    public int countSubIslands(int[][] grid1, int[][] grid2) {
        rows = grid1.length;
        cols = grid1[0].length;
        this.grid1 = grid1;
        this.grid2 = grid2;
        int count = 0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid2[i][j] == 1 && bfs(i, j)) {
                    count++;
                }
            }
        }
        return count;
    }

    private boolean bfs(int i, int j) {
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[] { i, j });
        grid2[i][j] = 0;
        boolean flag = true;
        if (grid1[i][j] != 1) {
            flag = false;
        }
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            for (int[] d : dirs) {
                int newX = cur[0] + d[0];
                int newY = cur[1] + d[1];
                if (newX >= 0 && newX < rows && newY >= 0 && newY < cols && grid2[newX][newY] == 1) {
                    queue.offer(new int[] { newX, newY });
                    grid2[newX][newY] = 0;
                    if (grid1[newX][newY] == 0) {
                        flag = false;
                    }
                }
            }
        }
        return flag;
    }
}

flood fill题型总结

LeetCode 题目总结