Number of Islands II - Practice Coding Problems

Number of Islands II - Problem

Number of Islands II is a dynamic programming problem where you simulate the formation of islands over time.

You start with an empty m × n grid filled with water (represented by 0's). You're given a sequence of operations where each operation adds land (represented by 1) at a specific position. After each land addition, you need to count how many islands exist.

An island is a group of connected land cells (horizontally or vertically adjacent). When you add land, it might:
• Create a new island
• Join existing islands together
• Simply extend an existing island

Your task is to return an array where each element represents the number of islands after performing each land addition operation.

Example: If you have a 3×3 grid and add land at positions [[0,0], [0,1], [1,2], [2,1]], the island counts would change as you connect or create new land masses.

Input & Output

example_1.py — Basic Island Formation

$ Input: m = 3, n = 3, positions = [[0,0],[0,1],[1,2],[2,1]]

› Output: [1,1,2,3]

💡 Note: Initially grid is empty. Add (0,0) → 1 island. Add (0,1) → joins with (0,0), still 1 island. Add (1,2) → new island, total 2. Add (2,1) → new island, total 3.

example_2.py — Island Merging

$ Input: m = 1, n = 1, positions = [[0,0]]

› Output: [1]

💡 Note: Single cell grid. Adding land at (0,0) creates exactly 1 island.

example_3.py — Duplicate Positions

$ Input: m = 3, n = 3, positions = [[0,0],[0,1],[0,0],[1,1]]

› Output: [1,1,1,2]

💡 Note: Add (0,0) → 1 island. Add (0,1) → merge, still 1. Try (0,0) again → no change, still 1. Add (1,1) → connects to existing island, still 1... Wait, this would actually create 2 islands if (1,1) doesn't connect diagonally.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty ocean (Union-Find with m×n cells)

Add Land

Place land and assume it creates a new island (+1 count)

Check Neighbors

Look at 4 adjacent cells for existing land

Union Components

For each land neighbor, merge components and decrement count

Record State

Add current island count to result array

Key Takeaway

🎯 Key Insight: Union-Find transforms an O(k·m·n) problem into O(k·α(mn)) by maintaining dynamic connectivity without expensive grid traversals. Each land addition requires only checking 4 neighbors and potentially 4 union operations.

Time & Space Complexity

Time Complexity

⏱️

O(k × α(mn))

k operations, each with at most 4 union operations. α is inverse Ackermann function (practically constant)

✓ Linear Growth

Space Complexity

O(mn)

Union-Find parent array and rank array, plus set to track added positions

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 10⁴
1 ≤ positions.length ≤ 10⁴
0 ≤ positions[i][0] < m
0 ≤ positions[i][1] < n
positions may contain duplicate coordinates

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 25

The optimal solution uses Union-Find data structure to efficiently track connected components. Instead of traversing the entire grid after each operation, we maintain dynamic connectivity by checking only the 4 neighbors of newly added land. When land connects existing islands, we union their components and decrement the island count. With path compression and union by rank, this achieves O(k × α(mn)) time complexity, where α is the inverse Ackermann function (practically constant).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS/BFS after each operation)	O(k × m × n)	O(m × n)	After each land addition, traverse entire grid to count islands
Union-Find (Optimal)	O(k × α(mn))	O(mn)	Use Union-Find to efficiently track and merge connected components

Brute Force (DFS/BFS after each operation) — Algorithm Steps

Initialize empty m×n grid
For each position in operations:
- Add land at given position
- Run DFS/BFS on entire grid to count islands
- Add count to result array
Return result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Land

Place new land at specified position

Full Grid Scan

Traverse entire grid with DFS/BFS

Count Islands

Count all separate island groups found

Repeat

Repeat for each operation

Code -

solution.c — C

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

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

void dfs(int i, int j, bool** visited) {
    if (i < 0 || i >= m || j < 0 || j >= n || 
        visited[i][j] || grid[i][j] == 0) {
        return;
    }
    visited[i][j] = true;
    for (int k = 0; k < 4; k++) {
        dfs(i + directions[k][0], j + directions[k][1], visited);
    }
}

int countIslands() {
    bool** visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    int count = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1 && !visited[i][j]) {
                dfs(i, j, visited);
                count++;
            }
        }
    }
    
    for (int i = 0; i < m; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return count;
}

int* numIslands2(int rows, int cols, int** positions, int positionsSize, int* returnSize) {
    m = rows;
    n = cols;
    
    grid = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        grid[i] = (int*)calloc(n, sizeof(int));
    }
    
    int* result = (int*)malloc(positionsSize * sizeof(int));
    *returnSize = positionsSize;
    
    for (int i = 0; i < positionsSize; i++) {
        grid[positions[i][0]][positions[i][1]] = 1;
        result[i] = countIslands();
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × m × n)

For k operations, each requiring O(m×n) grid traversal to count islands

✓ Linear Growth

Space Complexity

O(m × n)

Space for the grid plus recursion stack for DFS (up to m×n in worst case)

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 10⁴
1 ≤ positions.length ≤ 10⁴
0 ≤ positions[i][0] < m
0 ≤ positions[i][1] < n
positions may contain duplicate coordinates

67.2K Views

High Frequency

~25 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 (DFS/BFS after each operation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler