Number of Distinct Islands - Practice Coding Problems

Number of Distinct Islands - Problem

Discover Unique Island Shapes! 🏝️

You're an explorer surveying a vast ocean represented by an m x n binary grid. In this grid, 1 represents land and 0 represents water. Islands are formed by groups of connected land cells that touch each other horizontally or vertically (4-directional connectivity).

Here's the twist: you need to identify how many distinct island shapes exist in this ocean. Two islands are considered the same shape if one can be translated (moved without rotation or reflection) to perfectly match the other.

Your Mission: Count the number of unique island shapes in the grid.

Example:
Grid: [[1,1,0],[0,1,1],[0,0,0]]
This contains one L-shaped island, so the answer is 1.

Input & Output

example_1.py — Basic L-shaped island

$ Input: grid = [[1,1,0,0,0],[1,0,0,0,0],[0,0,0,1,1],[0,0,0,1,1]]

› Output: 1

💡 Note: The grid contains two identical L-shaped islands that can be translated to match each other exactly. Since they have the same shape, there is only 1 distinct island shape.

example_2.py — Different shaped islands

$ Input: grid = [[1,1,0,1,1],[1,0,0,0,0],[0,0,0,0,1],[1,1,0,1,1]]

› Output: 3

💡 Note: This grid contains three different island shapes: an L-shape, a single cell, and a 2x1 rectangle. Each has a unique structure, so there are 3 distinct islands.

example_3.py — Single large island

$ Input: grid = [[1,1,1],[1,1,1]]

› Output: 1

💡 Note: The entire grid forms one connected island in a 2x3 rectangular shape. Since there's only one island, the answer is 1.

Visualization

Tap to expand

Understanding the Visualization

Discover Islands

Scan the grid to find uncharted islands using DFS exploration

Encode Shape

Create a unique signature by recording the path taken during exploration

Check Catalog

Compare against previously discovered shapes using hash set lookup

Update Collection

Add new unique shapes to our catalog of distinct island types

Key Takeaway

🎯 Key Insight: By encoding each island's shape as a unique DFS path signature, we can identify duplicates in constant time, achieving optimal performance with a single grid traversal.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is visited exactly once during DFS traversal

✓ Linear Growth

Space Complexity

O(m*n)

Hash set stores unique island signatures, visited array, and DFS recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 50
grid[i][j] is either 0 or 1
Islands are connected 4-directionally (horizontal and vertical only)
All four edges of the grid are surrounded by water

Asked in

G Google 47 f Facebook 35 a Amazon 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses DFS with path encoding to create unique signatures for each island shape. During traversal, we record the sequence of moves (directions) as a string, making each island's shape identifiable in O(1) time using a hash set. This achieves O(m×n) time complexity with a single pass through the grid.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Compare All Islands)	O(mn + k²s)	O(k*s)	Find all islands, then compare each pair to check if they have the same shape
DFS with Path Encoding (Optimal)	O(m*n)	O(m*n)	Encode each island's shape as a unique path signature during DFS traversal

Brute Force (Compare All Islands) — Algorithm Steps

Use DFS to find all islands and store their cell coordinates
For each pair of islands, try all possible translations
Check if one island can be translated to match the other exactly
Count islands that don't match any previously seen island

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Islands

Use DFS to discover all islands and store their coordinates

Normalize Shapes

Translate each island to start from origin (0,0)

Compare Pairs

Check every island against every other island for matching shapes

Count Unique

Keep track of islands that don't match any previously seen shape

Code -

solution.c — C

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

#define MAX_CELLS 10000

typedef struct {
    int r, c;
} Cell;

typedef struct {
    Cell cells[MAX_CELLS];
    int size;
} Island;

int m, n;
int directions[4][2] = {{1,0}, {-1,0}, {0,1}, {0,-1}};

void dfs(int** grid, int i, int j, bool** visited, Island* island) {
    if (i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || grid[i][j] == 0) {
        return;
    }
    
    visited[i][j] = true;
    island->cells[island->size].r = i;
    island->cells[island->size].c = j;
    island->size++;
    
    for (int d = 0; d < 4; d++) {
        dfs(grid, i + directions[d][0], j + directions[d][1], visited, island);
    }
}

int compare_cells(const void* a, const void* b) {
    Cell* ca = (Cell*)a;
    Cell* cb = (Cell*)b;
    if (ca->r != cb->r) return ca->r - cb->r;
    return ca->c - cb->c;
}

void normalize_island(Island* island) {
    if (island->size == 0) return;
    
    int minR = island->cells[0].r, minC = island->cells[0].c;
    for (int i = 1; i < island->size; i++) {
        if (island->cells[i].r < minR) minR = island->cells[i].r;
        if (island->cells[i].c < minC) minC = island->cells[i].c;
    }
    
    for (int i = 0; i < island->size; i++) {
        island->cells[i].r -= minR;
        island->cells[i].c -= minC;
    }
    
    qsort(island->cells, island->size, sizeof(Cell), compare_cells);
}

bool same_shape(Island* island1, Island* island2) {
    if (island1->size != island2->size) return false;
    
    Island norm1 = *island1, norm2 = *island2;
    normalize_island(&norm1);
    normalize_island(&norm2);
    
    for (int i = 0; i < norm1.size; i++) {
        if (norm1.cells[i].r != norm2.cells[i].r || norm1.cells[i].c != norm2.cells[i].c) {
            return false;
        }
    }
    return true;
}

int numDistinctIslands(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    m = gridSize;
    n = gridColSize[0];
    
    // Create visited array
    bool** visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    Island islands[1000];
    int island_count = 0;
    
    // Find all islands
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1 && !visited[i][j]) {
                islands[island_count].size = 0;
                dfs(grid, i, j, visited, &islands[island_count]);
                island_count++;
            }
        }
    }
    
    // Count distinct islands
    Island distinct[1000];
    int distinct_count = 0;
    
    for (int i = 0; i < island_count; i++) {
        bool is_distinct = true;
        for (int j = 0; j < distinct_count; j++) {
            if (same_shape(&islands[i], &distinct[j])) {
                is_distinct = false;
                break;
            }
        }
        if (is_distinct) {
            distinct[distinct_count] = islands[i];
            distinct_count++;
        }
    }
    
    // Clean up
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return distinct_count;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n + k²*s)

O(m*n) to scan grid, O(k²*s) to compare k islands with average size s

✓ Linear Growth

Space Complexity

O(k*s)

Storage for k islands with average size s cells each

✓ Linear Space

Constraints

1 ≤ m, n ≤ 50
grid[i][j] is either 0 or 1
Islands are connected 4-directionally (horizontal and vertical only)
All four edges of the grid are surrounded by water

42.4K 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

Brute Force (Compare All Islands) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler