Number of Distinct Islands II - 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 they have the same shape, or have the same shape after rotation (90, 180, or 270 degrees only) or reflection (left/right direction or up/down direction).

Return the number of distinct islands.

Input & Output

Example 1 — Basic Grid with Two Distinct Islands

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

› Output: 2

💡 Note: First island is L-shaped at positions (0,0), (0,1), (1,1). Second island is T-shaped at positions (3,0), (3,1), (3,2), (4,1). These are different shapes even after all rotations and reflections.

Example 2 — Same Shape Different Orientations

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

› Output: 1

💡 Note: First island: L-shape at (0,0), (0,1), (1,0). Second island: vertical line at (1,3), (2,3), (3,3). The L can be rotated 90° clockwise to become a vertical line, so they're the same shape.

Example 3 — Single Cell Islands

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

› Output: 1

💡 Note: All three islands are single cells. All single-cell islands have the same shape regardless of position, so there's only 1 distinct shape.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 25 f Facebook 20 M Microsoft 15

This problem requires finding distinct island shapes considering all possible rotations and reflections. The key insight is to generate all 8 transformations (4 rotations × 2 reflections) for each island and normalize them to a canonical form. Best approach uses DFS to find islands, then hash normalized forms. Time: O(n² × k), Space: O(n²)

Common Approaches

✓ Brute Force Comparison

⏱️ Time: O(n⁴) Space: O(n²)

Find all islands using DFS, then for each pair of islands, check if they match after applying any of the 8 possible transformations (4 rotations × 2 reflections).

DFS with Shape Normalization

⏱️ Time: O(n² * k) Space: O(n²)

Extract islands using DFS, then for each island generate all 8 possible transformations (rotations and reflections). Use a hash set to store normalized canonical forms and count unique shapes.

Hash Map with Complex Coordinates

⏱️ Time: O(n² * k) Space: O(n²)

Represent island coordinates as complex numbers where rotation becomes multiplication by i. This makes generating transformations more elegant and reduces code complexity while maintaining the same algorithmic approach.

Brute Force Comparison — Algorithm Steps

Step 1: Extract all islands using DFS
Step 2: For each island pair, try all 8 transformations
Step 3: Count islands that don't match any previous island

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Islands

Use DFS to find all connected components

Compare Pairs

For each island pair, try all 8 transformations

Count Distinct

Keep islands that don't match any previous one

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

typedef struct {
    Point* points;
    int size;
    int capacity;
} Island;

static int** grid;
static bool** visited;
static int m, n;
static Island islands[10000];
static int islandCount = 0;

// Add point to island
void addPoint(Island* island, int x, int y) {
    if (island->size >= island->capacity) {
        island->capacity *= 2;
        island->points = (Point*)realloc(island->points, island->capacity * sizeof(Point));
    }
    island->points[island->size].x = x;
    island->points[island->size].y = y;
    island->size++;
}

void dfs(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;
    addPoint(island, i, j);
    dfs(i+1, j, island);
    dfs(i-1, j, island);
    dfs(i, j+1, island);
    dfs(i, j-1, island);
}

// Helper function to compare points for sorting
int comparePoints(const void* a, const void* b) {
    Point* p1 = (Point*)a;
    Point* p2 = (Point*)b;
    if (p1->x != p2->x) return p1->x - p2->x;
    return p1->y - p2->y;
}

// Normalize island coordinates
void normalize(Point* points, int size, Point* normalized) {
    if (size == 0) return;
    
    // Find minimum coordinates
    int minX = points[0].x, minY = points[0].y;
    for (int i = 1; i < size; i++) {
        if (points[i].x < minX) minX = points[i].x;
        if (points[i].y < minY) minY = points[i].y;
    }
    
    // Normalize points
    for (int i = 0; i < size; i++) {
        normalized[i].x = points[i].x - minX;
        normalized[i].y = points[i].y - minY;
    }
    
    // Sort points
    qsort(normalized, size, sizeof(Point), comparePoints);
}

// Compare two normalized islands
int compareIslands(Point* a, int sizeA, Point* b, int sizeB) {
    int minSize = sizeA < sizeB ? sizeA : sizeB;
    for (int i = 0; i < minSize; i++) {
        if (a[i].x != b[i].x) return a[i].x - b[i].x;
        if (a[i].y != b[i].y) return a[i].y - b[i].y;
    }
    return sizeA - sizeB;
}

// Get canonical form of island
void getCanonicalForm(Island* island, Point* canonical) {
    Point* temp = (Point*)malloc(island->size * sizeof(Point));
    Point* normalized = (Point*)malloc(island->size * sizeof(Point));
    Point* bestCanonical = (Point*)malloc(island->size * sizeof(Point));
    bool first = true;
    
    // Generate all 8 transformations
    
    // Original and 3 rotations
    for (int i = 0; i < island->size; i++) {
        temp[i] = island->points[i];
    }
    for (int rot = 0; rot < 4; rot++) {
        normalize(temp, island->size, normalized);
        if (first || compareIslands(normalized, island->size, bestCanonical, island->size) < 0) {
            memcpy(bestCanonical, normalized, island->size * sizeof(Point));
            first = false;
        }
        // Rotate 90 degrees clockwise: (x,y) -> (y,-x)
        for (int i = 0; i < island->size; i++) {
            int oldX = temp[i].x;
            temp[i].x = temp[i].y;
            temp[i].y = -oldX;
        }
    }
    
    // Flip horizontally and 3 more rotations
    for (int i = 0; i < island->size; i++) {
        temp[i].x = -island->points[i].x; // Flip over horizontal axis
        temp[i].y = island->points[i].y;
    }
    for (int rot = 0; rot < 4; rot++) {
        normalize(temp, island->size, normalized);
        if (compareIslands(normalized, island->size, bestCanonical, island->size) < 0) {
            memcpy(bestCanonical, normalized, island->size * sizeof(Point));
        }
        // Rotate 90 degrees clockwise: (x,y) -> (y,-x)
        for (int i = 0; i < island->size; i++) {
            int oldX = temp[i].x;
            temp[i].x = temp[i].y;
            temp[i].y = -oldX;
        }
    }
    
    memcpy(canonical, bestCanonical, island->size * sizeof(Point));
    
    free(temp);
    free(normalized);
    free(bestCanonical);
}

int solution(int** inputGrid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        return 0;
    }
    
    grid = inputGrid;
    m = gridSize;
    n = gridColSize[0];
    islandCount = 0;
    
    // Create visited array
    visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    // 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].points = (Point*)malloc(10 * sizeof(Point));
                islands[islandCount].size = 0;
                islands[islandCount].capacity = 10;
                dfs(i, j, &islands[islandCount]);
                if (islands[islandCount].size > 0) {
                    islandCount++;
                }
            }
        }
    }
    
    // Get canonical forms and count distinct ones
    Point** canonicalForms = (Point**)malloc(islandCount * sizeof(Point*));
    int* canonicalSizes = (int*)malloc(islandCount * sizeof(int));
    int distinctCount = 0;
    
    for (int i = 0; i < islandCount; i++) {
        Point* canonical = (Point*)malloc(islands[i].size * sizeof(Point));
        getCanonicalForm(&islands[i], canonical);
        
        bool found = false;
        for (int j = 0; j < distinctCount; j++) {
            if (canonicalSizes[j] == islands[i].size && 
                compareIslands(canonical, islands[i].size, canonicalForms[j], canonicalSizes[j]) == 0) {
                found = true;
                break;
            }
        }
        
        if (!found) {
            canonicalForms[distinctCount] = canonical;
            canonicalSizes[distinctCount] = islands[i].size;
            distinctCount++;
        } else {
            free(canonical);
        }
    }
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    
    for (int i = 0; i < islandCount; i++) {
        free(islands[i].points);
    }
    
    for (int i = 0; i < distinctCount; i++) {
        free(canonicalForms[i]);
    }
    free(canonicalForms);
    free(canonicalSizes);
    
    return distinctCount;
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("0\n");
        return 0;
    }
    
    // Parse JSON-like input
    int** grid = NULL;
    int gridSize = 0;
    int* gridColSize = NULL;
    
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    int capacity = 10;
    grid = (int**)malloc(capacity * sizeof(int*));
    gridColSize = (int*)malloc(capacity * sizeof(int));
    
    while (*p) {
        while (*p && (*p == ' ' || *p == '\n')) p++;
        if (*p != '[') break;
        p++;
        
        int* row = (int*)malloc(100 * sizeof(int));
        int colCount = 0;
        
        while (*p && *p != ']') {
            while (*p && (*p == ' ' || *p == ',')) p++;
            if (*p >= '0' && *p <= '9') {
                row[colCount++] = *p - '0';
                p++;
            } else {
                p++;
            }
        }
        
        if (colCount > 0) {
            if (gridSize >= capacity) {
                capacity *= 2;
                grid = (int**)realloc(grid, capacity * sizeof(int*));
                gridColSize = (int*)realloc(gridColSize, capacity * sizeof(int));
            }
            grid[gridSize] = row;
            gridColSize[gridSize] = colCount;
            gridSize++;
        } else {
            free(row);
        }
        
        if (*p == ']') p++;
        while (*p && (*p == ' ' || *p == ',' || *p == '\n')) p++;
    }
    
    int result = solution(grid, gridSize, gridColSize);
    printf("%d\n", result);
    
    // Cleanup
    for (int i = 0; i < gridSize; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

For each island pair, we try 8 transformations, each taking O(island_size) time

✓ Linear Growth

Space Complexity

O(n²)

Store all islands and their coordinates

⚠ Quadratic Space

32.0K Views

Medium Frequency

~35 min Avg. Time

845 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 II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler