⚠️ This visualization was AI-generated and may contain inaccuracies. Please verify against the original LeetCode problem (#200) before relying on it.

Number of Islands

An interactive visualization of DFS flood fill on a 2D grid. Watch how depth-first search discovers and marks each connected island, one cell at a time.

DFS LeetCode 200 ↗ Medium

The Problem

Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.

An island is surrounded by water and is formed by connecting adjacent land cells horizontally or vertically. You may assume all four edges of the grid are surrounded by water.

Interactive Visualization

Grid (rows separated by commas)

Preset

Speed:

Grid Visualization

Code

fun numIslands(grid: Array<CharArray>): Int {    if (grid.isEmpty()) return 0    val rows = grid.size    val cols = grid[0].size    var count = 0    fun dfs(r: Int, c: Int) {        if (r < 0 || r >= rows ||            c < 0 || c >= cols ||            grid[r][c] != '1')            return        grid[r][c] = '#'  // mark visited        dfs(r + 1, c)        dfs(r - 1, c)        dfs(r, c + 1)        dfs(r, c - 1)    }    for (r in 0 until rows) {        for (c in 0 until cols) {            if (grid[r][c] == '1') {                count++                dfs(r, c)            }    }   }   return count }

def numIslands(grid):    if not grid:        return 0    rows, cols = len(grid), len(grid[0])    count = 0    def dfs(r, c):        if (r < 0 or r >= rows or            c < 0 or c >= cols or            grid[r][c] != '1'):            return        grid[r][c] = '#'  # mark visited        dfs(r + 1, c)        dfs(r - 1, c)        dfs(r, c + 1)        dfs(r, c - 1)    for r in range(rows):        for c in range(cols):            if grid[r][c] == '1':                count += 1                dfs(r, c)    return count

Status

Press Step or Play to begin.

How It Works

Key Insight

Every unvisited land cell ('1') is either part of an already-counted island or the start of a brand-new one. When we find an unvisited '1', we increment the island count and use DFS to "flood fill" the entire connected component, marking every reachable land cell as visited so it won't be counted again.

The Algorithm

Scan: Iterate through every cell in the grid row by row, column by column.
Detect new island: When we encounter a '1' (unvisited land), increment count and launch a DFS from that cell.
DFS flood fill: Mark the current cell as visited ('#'), then recursively visit all four neighbors (up, down, left, right).
Base case: If the cell is out of bounds, water ('0'), or already visited ('#'), return immediately.
Result: After scanning the entire grid, count holds the total number of islands.

Complexity

Time O(m × n)

Space O(m × n)

Every cell is visited at most once during scanning and at most once during DFS, giving O(m × n) time. The space complexity is O(m × n) in the worst case for the recursion stack — imagine a grid filled entirely with land, where DFS would recurse through all m × n cells.