Number of Islands

Number of Islands - Problem

Imagine you're a cartographer analyzing satellite imagery of an archipelago! You have a 2D grid map where '1' represents land and '0' represents water. Your mission is to count how many separate islands exist in this region.

An island is formed by connecting adjacent land cells ('1's) either horizontally or vertically (diagonal connections don't count). Think of it like walking from one piece of land to another - you can only move up, down, left, or right.

Example: If you see connected land masses, they form a single island. Separate land masses surrounded by water are different islands.

The entire grid is surrounded by water, so any land on the edges is still considered part of an island if connected to other land.

Input & Output

example_1.py — Basic Islands

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

› Output: 1

💡 Note: All the 1's are connected horizontally or vertically, forming one large island surrounded by water.

example_2.py — Multiple Islands

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

› Output: 3

💡 Note: There are three separate islands: one 2x2 island in top-left, one single cell in middle, and one 1x2 island in bottom-right.

example_3.py — Single Cell

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

› Output: 1

💡 Note: Edge case with just one cell containing land forms exactly one island.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 300
grid[i][j] is '0' or '1'
Grid cells contain only characters '0' and '1'

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses graph traversal (DFS or BFS) to explore connected components. When we find an unvisited land cell, we increment our island count and use DFS/BFS to mark the entire connected island as visited. This ensures each island is counted exactly once with O(m × n) time complexity.

Common Approaches

✓ BFS with Queue (Optimal)

⏱️ Time: O(m × n) Space: O(min(m, n))

Similar to DFS approach but uses Breadth-First Search with a queue. When we find a '1', we add it to queue and explore all connected land cells level by level. This avoids potential stack overflow issues with deep recursion and provides iterative solution.

Brute Force with DFS

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

Iterate through every cell in the grid. When we find a '1' (land), we increment our island count and use Depth-First Search to mark all connected land cells as visited (change them to '0' or use a visited array). This prevents counting the same island multiple times.

BFS with Queue (Optimal) — Algorithm Steps

Initialize island counter and create a queue
Iterate through each cell in the grid
When we find a '1', increment counter and add to queue
Use BFS to explore all connected cells from queue
Mark visited cells and add new land neighbors to queue
Continue until queue is empty, then resume grid scan

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Island Start

Discover first land cell of new island

Add to Queue

Add starting cell to BFS queue

Explore Level

Process all cells at current level

Add Neighbors

Add adjacent land cells to queue

Complete Island

Continue until entire island is explored

Code -

solution.c — C

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

typedef struct {
    int r, c;
} Point;

typedef struct {
    Point* data;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (Point*)malloc(sizeof(Point) * capacity);
    q->front = q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, Point p) {
    q->data[q->rear] = p;
    q->rear = (q->rear + 1) % q->capacity;
}

Point dequeue(Queue* q) {
    Point p = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    return p;
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

void bfs(char** grid, int rows, int cols, int start_r, int start_c, int directions[4][2]) {
    Queue* queue = createQueue(rows * cols);
    enqueue(queue, (Point){start_r, start_c});
    grid[start_r][start_c] = '0';
    
    while (!isEmpty(queue)) {
        Point curr = dequeue(queue);
        int r = curr.r;
        int c = curr.c;
        
        for (int i = 0; i < 4; i++) {
            int nr = r + directions[i][0];
            int nc = c + directions[i][1];
            
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == '1') {
                grid[nr][nc] = '0';
                enqueue(queue, (Point){nr, nc});
            }
        }
    }
    
    free(queue->data);
    free(queue);
}

int numIslands(char** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) {
        return 0;
    }
    
    int rows = gridSize;
    int cols = gridColSize[0];
    int islands = 0;
    int directions[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            if (grid[r][c] == '1') {
                islands++;
                bfs(grid, rows, cols, r, c, directions);
            }
        }
    }
    
    return islands;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* gridStart = strstr(input, "[[");
    if (!gridStart) {
        printf("0\n");
        return 0;
    }
    
    // Count rows by counting opening brackets after the first one
    int rows = 0;
    char* p = gridStart + 1;
    while (*p) {
        if (*p == '[') rows++;
        p++;
    }
    
    if (rows == 0) {
        printf("0\n");
        return 0;
    }
    
    char** grid = (char**)malloc(rows * sizeof(char*));
    int* gridColSize = (int*)malloc(rows * sizeof(int));
    
    p = gridStart + 1;
    for (int i = 0; i < rows; i++) {
        // Find start of row
        while (*p && *p != '[') p++;
        if (!*p) break;
        p++; // skip [
        
        // Count columns by counting quoted characters
        char* rowStart = p;
        int cols = 0;
        while (*p && *p != ']') {
            if (*p == '"') cols++;
            p++;
        }
        cols /= 2; // Each element has 2 quotes
        
        gridColSize[i] = cols;
        grid[i] = (char*)malloc(cols * sizeof(char));
        
        // Extract characters
        p = rowStart;
        int colIdx = 0;
        while (*p && *p != ']' && colIdx < cols) {
            if (*p == '"') {
                p++; // skip opening quote
                grid[i][colIdx++] = *p;
                p++; // skip the character
                if (*p == '"') p++; // skip closing quote
            } else {
                p++;
            }
        }
        
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
    }
    
    int result = numIslands(grid, rows, gridColSize);
    printf("%d\n", result);
    
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Each cell is visited exactly once, either during grid scan or BFS traversal

✓ Linear Growth

Space Complexity

O(min(m, n))

Queue size can be at most min(m,n) in worst case when BFS explores diagonally

⚡ Linearithmic Space

67.8K Views

Very High Frequency

~15 min Avg. Time

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

BFS with Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler