Count Sub Islands

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.

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)

Visualization

Tap to expand

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

✓ Single Pass DFS with Validation (Optimal)

⏱️ Time: O(m*n) Space: O(m*n)

This optimal approach combines island detection and validation in a single DFS traversal. For each unvisited land cell in grid2, we perform DFS to explore the entire island while simultaneously checking if every cell corresponds to land in grid1. If any cell fails validation, we know immediately that the entire island is invalid.

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>
#include <string.h>

static int grid1[500][500];
static int grid2[500][500];
static int grid2Copy[500][500];
static int rows, cols;

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

int countSubIslands() {
    // Copy grid2 to grid2Copy
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            grid2Copy[i][j] = grid2[i][j];
        }
    }
    
    int count = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid2Copy[i][j] == 1) {
                if (dfs(i, j)) {
                    count++;
                }
            }
        }
    }
    return count;
}

void parseGrid(char* str, int grid[][500]) {
    char* ptr = str + 1; // Skip first '['
    int row = 0, col = 0;
    
    while (*ptr) {
        if (*ptr == '[') {
            col = 0;
        } else if (*ptr >= '0' && *ptr <= '9') {
            grid[row][col] = *ptr - '0';
            col++;
        } else if (*ptr == ']' && *(ptr+1) != ']') {
            if (col > 0) {
                if (cols == 0) cols = col;
                row++;
            }
        }
        ptr++;
    }
    if (rows == 0) rows = row;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    parseGrid(line1, grid1);
    parseGrid(line2, grid2);
    
    int result = countSubIslands();
    printf("%d\n", result);
    
    return 0;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Single Pass DFS with Validation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler