Count Sub Islands - Practice Coding Problems

Count Sub Islands - Problem

Island Adventure: Finding Sub-Islands!

You're an oceanographer studying two different maps of the same ocean region. You have two m x n binary grids representing the same area at different times:

• grid1: The reference map (0 = water, 1 = land)
• grid2: The current map (0 = water, 1 = land)

An island is a group of connected land cells (1's) that touch horizontally or vertically. Your mission is to find how many islands in grid2 are completely contained within islands from grid1.

What makes a sub-island?
An island in grid2 is a sub-island if every single cell of that island corresponds to land (1) in grid1. If even one cell of the island in grid2 is water (0) in grid1, then it's not a sub-island.

Goal: Return the total count of valid sub-islands in grid2.

Input & Output

example_1.py — Basic Sub-Island Detection

$ 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

💡 Note: Grid2 has several islands, but only 3 qualify as sub-islands: (1) Top-left island at (0,0)-(0,2) matches land in grid1, (2) Island at (1,3)-(1,4) corresponds to land in grid1, (3) Single cell island at (3,0) matches grid1. Other islands fail because they contain cells that are water in grid1.

example_2.py — All Valid Sub-Islands

$ 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,0,0,0,0],[0,1,1,1,0],[0,0,0,0,0]]

› Output: 1

💡 Note: Grid2 has 2 islands: one large island in row 1 and a smaller island in row 3. The large island (1,0)-(1,4) perfectly matches land in grid1, making it a valid sub-island. The smaller island (3,1)-(3,3) also corresponds to land in grid1, making it valid too. Wait - let me recount: there's actually 1 connected island spanning positions that all correspond to land in grid1.

example_3.py — No Valid Sub-Islands

$ Input: grid1 = [[1,0,0,0,1],[0,1,1,1,0],[0,1,1,1,0],[0,1,1,1,0],[1,0,0,0,1]] grid2 = [[0,1,1,1,0],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[0,1,1,1,0]]

› Output: 0

💡 Note: Every island in grid2 contains at least one cell that corresponds to water (0) in grid1. For example, the top island in grid2 at positions (0,1)-(0,3) overlaps with water in grid1, making it invalid. Similarly, all other islands fail the sub-island test.

Visualization

Tap to expand

Understanding the Visualization

Island Discovery

Find connected land cells in grid2 using DFS traversal

Simultaneous Validation

For each cell in current island, verify it corresponds to land in grid1

Early Termination

If any cell fails validation, mark entire island as invalid

Count Valid Islands

Increment counter only for islands that pass complete validation

Key Takeaway

🎯 Key Insight: Use DFS to explore each island while simultaneously validating every cell against grid1. Any invalid cell invalidates the entire island - this single-pass approach is both elegant and optimal!

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Single pass through grid with each cell visited exactly once during DFS exploration

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack for DFS, worst case when entire grid forms one connected island

⚡ Linearithmic Space

Constraints

Grid dimensions: m == grid1.length == grid2.length
Grid dimensions: n == grid1[i].length == grid2[i].length
Size limits: 1 ≤ m, n ≤ 500
Cell values: grid1[i][j] and grid2[i][j] are either 0 or 1
Definition: Islands are 4-directionally connected (no diagonal connections)

Asked in

G Google 42 a Amazon 38 f Meta 35 ⊞ Microsoft 28 Apple 22

The optimal solution uses single-pass DFS to explore each island in grid2 while simultaneously validating that every cell corresponds to land in grid1. Key insight: if any cell in an island is invalid, the entire island fails the sub-island test. This approach achieves O(m*n) time complexity with a single traversal, making it more efficient than multi-pass approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass DFS with Validation (Optimal)	O(m*n)	O(m*n)	Check validity while exploring each island in a single traversal

Single Pass DFS with Validation (Optimal) — Algorithm Steps

Iterate through each cell in grid2
When finding an unvisited land cell, start DFS exploration
During DFS, track whether current island is valid (all cells match land in grid1)
Mark visited cells to avoid reprocessing
If entire island is valid, increment counter
Return total count of valid sub-islands

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin exploration from unvisited land cell in grid2

Validate Each Cell

Check if current cell corresponds to land in grid1

Propagate Validity

Combine validation results from all connected cells

Count Valid Islands

Increment counter only if entire island is valid

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool dfs(int** grid1, int** grid2, int gridSize, int* gridColSize, int i, int j) {
    if (i < 0 || i >= gridSize || j < 0 || j >= gridColSize[0] || grid2[i][j] == 0) {
        return true;
    }
    
    // Mark current cell as visited
    grid2[i][j] = 0;
    
    // Check if current cell is valid
    bool isValid = grid1[i][j] == 1;
    
    // Explore all 4 directions and combine validity
    isValid = dfs(grid1, grid2, gridSize, gridColSize, i+1, j) && isValid;
    isValid = dfs(grid1, grid2, gridSize, gridColSize, i-1, j) && isValid;
    isValid = dfs(grid1, grid2, gridSize, gridColSize, i, j+1) && isValid;
    isValid = dfs(grid1, grid2, gridSize, gridColSize, i, j-1) && isValid;
    
    return isValid;
}

int countSubIslands(int** grid1, int grid1Size, int* grid1ColSize, int** grid2, int grid2Size, int* grid2ColSize) {
    int count = 0;
    for (int i = 0; i < grid1Size; i++) {
        for (int j = 0; j < grid1ColSize[0]; j++) {
            if (grid2[i][j] == 1) {
                if (dfs(grid1, grid2, grid1Size, grid1ColSize, i, j)) {
                    count++;
                }
            }
        }
    }
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Single pass through grid with each cell visited exactly once during DFS exploration

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack for DFS, worst case when entire grid forms one connected island

⚡ Linearithmic Space

Constraints

Grid dimensions: m == grid1.length == grid2.length
Grid dimensions: n == grid1[i].length == grid2[i].length
Size limits: 1 ≤ m, n ≤ 500
Cell values: grid1[i][j] and grid2[i][j] are either 0 or 1
Definition: Islands are 4-directionally connected (no diagonal connections)

48.2K Views

Medium-High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Single Pass DFS with Validation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler