Max Area of Island - Practice Coding Problems

Max Area of Island - Problem

Imagine you're an aerial photographer capturing images of a tropical archipelago! You have a binary matrix representing a satellite view where 1 represents land and 0 represents water.

Your mission: find the largest island in this beautiful archipelago. An island is a group of connected land cells (1's) that touch each other horizontally or vertically - diagonal connections don't count!

Goal: Return the area (number of cells) of the largest island. If there are no islands, return 0.

Example: In a grid like [[1,1,0],[0,1,0],[0,0,1]], we have two islands - one with area 3 (the connected group) and one with area 1, so we return 3.

Input & Output

example_1.py — Standard Grid

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

› Output: 4

💡 Note: There are two islands: one with area 4 (top-left) and one with area 4 (bottom-right). Both have the same area, so we return 4.

example_2.py — Single Cell Island

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

› Output: 6

💡 Note: The maximum area among all islands is 6 (there's a connected group of 6 ones somewhere in the grid).

example_3.py — No Islands

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

› Output: 0

💡 Note: There are no islands (no 1's) in the grid, so we return 0.

Visualization

Tap to expand

Understanding the Visualization

Start Survey

Begin systematic scan from top-left corner

Spot Land

When drone finds a '1', it starts mapping the island

Map Island

DFS explores all connected land, marking each cell as 'visited'

Count Area

Each land cell adds +1 to the island's total area

Continue Survey

Move to next unvisited cell and repeat until grid is complete

Key Takeaway

🎯 Key Insight: By using DFS and marking visited cells, we ensure each land cell is counted exactly once, achieving optimal O(m×n) time complexity while finding the largest connected component.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is visited exactly once during the grid traversal and DFS exploration

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack can go as deep as m*n in worst case (entire grid is one island)

⚡ Linearithmic Space

Constraints

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

Asked in

a Amazon 45 f Facebook 38 G Google 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses Depth-First Search (DFS) to explore each island exactly once. When we encounter a '1', we start DFS to explore the entire connected component, marking visited cells and counting the area. This achieves O(m×n) time complexity with each cell being processed exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Grid Modification (Optimal)	O(m*n)	O(m*n)	Use DFS to explore each island once, marking visited cells by modifying the grid

DFS with Grid Modification (Optimal) — Algorithm Steps

Iterate through every cell in the grid
When we find a '1', start DFS to explore the entire island
During DFS, change visited '1' cells to '0' to mark them as visited
Count the area of the current island during DFS
Keep track of the maximum area found so far
Return the maximum area

Visualization

Tap to expand

Step-by-Step Walkthrough

Find first island

Start DFS from the first '1' encountered

Explore and mark

DFS explores all connected cells, marking them as visited

Count area

Each cell adds 1 to the total area count

Skip visited cells

Already explored cells are now '0', so we skip them

Find next island

Continue until all cells are processed

Code -

solution.c — C

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

int dfs(int** grid, int gridSize, int* gridColSize, int i, int j) {
    // Check bounds and if current cell is water or already visited
    if (i < 0 || i >= gridSize || j < 0 || j >= gridColSize[i] || grid[i][j] == 0) {
        return 0;
    }
    
    // Mark current cell as visited
    grid[i][j] = 0;
    
    // Explore all 4 directions and count area
    int area = 1; // Count current cell
    area += dfs(grid, gridSize, gridColSize, i + 1, j); // Down
    area += dfs(grid, gridSize, gridColSize, i - 1, j); // Up
    area += dfs(grid, gridSize, gridColSize, i, j + 1); // Right
    area += dfs(grid, gridSize, gridColSize, i, j - 1); // Left
    
    return area;
}

int maxAreaOfIsland(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0) return 0;
    
    int maxArea = 0;
    for (int i = 0; i < gridSize; i++) {
        for (int j = 0; j < gridColSize[i]; j++) {
            if (grid[i][j] == 1) {
                // Found an unvisited island, explore it
                int currentArea = dfs(grid, gridSize, gridColSize, i, j);
                maxArea = currentArea > maxArea ? currentArea : maxArea;
            }
        }
    }
    
    return maxArea;
}

int main() {
    // Example usage
    int row1[] = {1,1,0,0,0};
    int row2[] = {1,1,0,0,0};
    int row3[] = {0,0,0,1,1};
    int row4[] = {0,0,0,1,1};
    int* grid[] = {row1, row2, row3, row4};
    int gridColSize[] = {5, 5, 5, 5};
    
    printf("%d\n", maxAreaOfIsland(grid, 4, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is visited exactly once during the grid traversal and DFS exploration

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack can go as deep as m*n in worst case (entire grid is one island)

⚡ Linearithmic Space

Constraints

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

78.5K Views

High Frequency

~15 min Avg. Time

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

DFS with Grid Modification (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler