【Leetcode】1905. Count Sub Islands

题目地址：

https://leetcode.com/problems/count-sub-islands/

给定两个$m\times n$的$0-1$矩阵$A$和$B$，$1$代表陆地，$1$连通块称为“岛屿”，$0$代表水。问$B$有多少个岛屿，如果将其完全平移到$A$的对应位置处，会被$A$的某个岛屿完全覆盖。

先将$A$里的每个岛屿用DFS编个号，从$2$开始编号。接着对$B$里的岛屿做DFS，只有当$A$的对应位置不是水的时候才进行DFS，在DFS的同时，每次走到一个位置，都看一下$A$的对应位置的编号是否等于入口位置的编号。如果某个时刻发现不是，则说明要么$B$的这个岛屿覆盖了$A$的水，要么覆盖了一个编号不同的岛屿，这都是不允许的。代码如下：

public class Solution {
    public int countSubIslands(int[][] grid1, int[][] grid2) {
        int m = grid1.length, n = grid1[0].length;
        int[] d = {-1, 0, 1, 0, -1};
        // 将每个岛屿进行编号，从2开始
        for (int i = 0, id = 2; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid1[i][j] == 1) {
                    dfs1(i, j, grid1, d, id++);
                }
            }
        }
        
        int res = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
            	// 走到B的一个岛屿了
                if (grid2[i][j] == 1) {
                	// 如果A的对应位置是水，那当前岛屿肯定不是“sub island”，略过
                	if (grid1[i][j] == 0) {
                        continue;
                    }
                    
                    // 否则说明grid1[i][j]是个岛屿编号，则进去DFS
                    if (dfs2(i, j, grid2, grid1, d, grid1[i][j])) {
                        res++;
                    }
                }
            }
        }
        
        return res;
    }
    
    private boolean dfs2(int x, int y, int[][] g, int[][] g1, int[] d, int id) {
    	// 看一下当前位置的g1是否还是入口的编号。注意，即使发现不是入口编号了，还是需要把整个岛DFS一遍，mark成已访问过
        boolean res = g1[x][y] == id;
        
        // 标记为已经访问过
        g[x][y] = 0;
        for (int i = 0; i < 4; i++) {
            int nextX = x + d[i], nextY = y + d[i + 1];
            if (0 <= nextX && nextX < g.length && 0 <= nextY && nextY < g[0].length && g[nextX][nextY] == 1) {
                res &= dfs2(nextX, nextY, g, g1, d, id);
            }
        }
        
        return res;
    }
    
    private void dfs1(int x, int y, int[][] g, int[] d, int id) {
        g[x][y] = id;
        for (int i = 0; i < 4; i++) {
            int nextX = x + d[i], nextY = y + d[i + 1];
            if (0 <= nextX && nextX < g.length && 0 <= nextY && nextY < g[0].length && g[nextX][nextY] == 1) {
                dfs1(nextX, nextY, g, d, id);
            }
        }
    }
}

时空复杂度$O(mn)$。