Number of Distinct Islands - Problem

You are given an m x n binary matrix grid. An island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical). You may assume all four edges of the grid are surrounded by water.

An island is considered to be the same as another if and only if one island can be translated (and not rotated or reflected) to equal the other.

Return the number of distinct islands.

Input & Output

Example 1 — Basic Islands

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

› Output: 1

💡 Note: The grid has 4 islands total, all with the same 2x2 square shape. When normalized, they all have the same relative coordinates: (0,0), (0,1), (1,0), (1,1). Therefore, there is only 1 distinct island shape.

Example 2 — L-shaped Islands

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

› Output: 2

💡 Note: First island is L-shaped at positions (0,0),(0,1),(1,0). Second island is a single cell at (2,2). These are 2 different shapes when normalized.

Example 3 — Single Cell

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

› Output: 1

💡 Note: All four islands are single cells at (0,0), (0,2), (2,0), (2,2). They all have the same shape: just one cell at relative position (0,0).

Constraints

1 ≤ m, n ≤ 50
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is that two islands are identical if they have the same relative coordinate pattern when normalized to start at (0,0). The optimal approach uses DFS with coordinate normalization to generate unique signatures for each island shape, then counts distinct signatures using a hash set. Time: O(mn), Space: O(mn).

Common Approaches

✓ Brute Force Island Comparison

⏱️ Time: O(m²n²k²) Space: O(mn)

First find all islands using DFS, store their coordinates, then for each pair of islands, try all possible translations to see if they match. This requires checking if one island can be moved to overlap exactly with another.

DFS with Path Encoding

⏱️ Time: O(mn) Space: O(mn)

During DFS traversal, encode the path taken as a string (e.g., 'DRUR' for Down, Right, Up, Right). Islands with identical shapes will generate identical path signatures, allowing us to use a set to count unique patterns efficiently.

Brute Force Island Comparison — Algorithm Steps

Find all islands and store their cell coordinates
For each pair of islands, check if they're identical by trying all translations
Count unique islands

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Islands

Use DFS to find all connected components of 1's

Normalize

Convert each island to relative coordinates starting from (0,0)

Compare

Check if any islands have identical normalized shapes

Code -

solution.c — C

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

#define MAX_CELLS 10000

typedef struct {
    int coords[MAX_CELLS][2];
    int size;
} Island;

Island islands[MAX_CELLS];
int islandCount = 0;
bool visited[100][100];
int m, n;

void dfs(int** grid, int i, int j, Island* island) {
    if (i < 0 || i >= m || j < 0 || j >= n || visited[i][j] || grid[i][j] == 0) {
        return;
    }
    visited[i][j] = true;
    island->coords[island->size][0] = i;
    island->coords[island->size][1] = j;
    island->size++;
    dfs(grid, i+1, j, island);
    dfs(grid, i-1, j, island);
    dfs(grid, i, j+1, island);
    dfs(grid, i, j-1, island);
}

int compareCoords(const void* a, const void* b) {
    int* coordA = (int*)a;
    int* coordB = (int*)b;
    if (coordA[0] != coordB[0]) return coordA[0] - coordB[0];
    return coordA[1] - coordB[1];
}

bool islandEquals(Island* a, Island* b) {
    if (a->size != b->size) return false;
    
    // Normalize islands
    int minIA = a->coords[0][0], minJA = a->coords[0][1];
    int minIB = b->coords[0][0], minJB = b->coords[0][1];
    
    for (int i = 0; i < a->size; i++) {
        if (a->coords[i][0] < minIA) minIA = a->coords[i][0];
        if (a->coords[i][1] < minJA) minJA = a->coords[i][1];
    }
    for (int i = 0; i < b->size; i++) {
        if (b->coords[i][0] < minIB) minIB = b->coords[i][0];
        if (b->coords[i][1] < minJB) minJB = b->coords[i][1];
    }
    
    // Create normalized copies
    int normalizedA[MAX_CELLS][2], normalizedB[MAX_CELLS][2];
    for (int i = 0; i < a->size; i++) {
        normalizedA[i][0] = a->coords[i][0] - minIA;
        normalizedA[i][1] = a->coords[i][1] - minJA;
    }
    for (int i = 0; i < b->size; i++) {
        normalizedB[i][0] = b->coords[i][0] - minIB;
        normalizedB[i][1] = b->coords[i][1] - minJB;
    }
    
    qsort(normalizedA, a->size, sizeof(int[2]), compareCoords);
    qsort(normalizedB, b->size, sizeof(int[2]), compareCoords);
    
    for (int i = 0; i < a->size; i++) {
        if (normalizedA[i][0] != normalizedB[i][0] || normalizedA[i][1] != normalizedB[i][1]) {
            return false;
        }
    }
    return true;
}

int solution(int** grid) {
    islandCount = 0;
    memset(visited, false, sizeof(visited));
    
    // 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[islandCount].size = 0;
                dfs(grid, i, j, &islands[islandCount]);
                islandCount++;
            }
        }
    }
    
    // Count unique islands
    bool unique[MAX_CELLS];
    for (int i = 0; i < islandCount; i++) unique[i] = true;
    
    for (int i = 0; i < islandCount; i++) {
        if (!unique[i]) continue;
        for (int j = i + 1; j < islandCount; j++) {
            if (unique[j] && islandEquals(&islands[i], &islands[j])) {
                unique[j] = false;
            }
        }
    }
    
    int count = 0;
    for (int i = 0; i < islandCount; i++) {
        if (unique[i]) count++;
    }
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small test cases
    m = 0;
    int** grid = malloc(100 * sizeof(int*));
    
    // Count rows first
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && line[i+1] != '[') m++;
    }
    
    // Allocate and parse (simplified for basic cases)
    for (int i = 0; i < m; i++) {
        grid[i] = malloc(100 * sizeof(int));
    }
    
    // Basic parsing - assumes simple format like [[1,1,0],[0,1,0]]
    int row = 0, col = 0;
    bool inNumber = false;
    int num = 0;
    
    for (int i = 0; line[i]; i++) {
        if (line[i] >= '0' && line[i] <= '9') {
            if (!inNumber) {
                num = 0;
                inNumber = true;
            }
            num = num * 10 + (line[i] - '0');
        } else {
            if (inNumber) {
                grid[row][col++] = num;
                inNumber = false;
            }
            if (line[i] == ']' && line[i+1] == ',' && line[i+2] == '[') {
                n = col;
                col = 0;
                row++;
            }
        }
    }
    if (col > 0) n = col;
    
    printf("%d\n", solution(grid));
    
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²k²)

Finding islands takes O(mn), comparing k islands pairwise takes O(k²) with O(mn) per comparison

⚠ Quadratic Growth

Space Complexity

O(mn)

Store all island coordinates and visited matrix

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Number of Distinct Islands - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Island Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler