Max Area of Island

Max Area of Island - 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.

The area of an island is the number of cells with a value 1 in the island.

Return the maximum area of an island in grid. If there is no island, return 0.

Input & Output

Example 1 — Basic Grid

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

› Output: 4

💡 Note: The largest island is the top-left 2x2 square of 1's, which has area 4. The bottom-right single 1 has area 1.

Example 2 — All Water

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

› Output: 0

💡 Note: There are no islands (no 1's), so the maximum area is 0.

Example 3 — Single Large Island

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

› Output: 8

💡 Note: All 1's are connected around the center 0, forming one island with area 8.

Constraints

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

Visualization

Tap to expand

Asked in

F Facebook 65 a Amazon 45 G Google 35 M Microsoft 28

The key insight is to use DFS or BFS to explore each island completely and mark visited cells to avoid recounting. The optimal approach is DFS with in-place marking, achieving Time: O(m×n), Space: O(m×n) for recursion stack.

Common Approaches

✓ Kadane

⏱️ Time: N/A Space: N/A

Optimized

⏱️ Time: N/A Space: N/A

Breadth-First Search

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

Similar to DFS but uses a queue to explore islands in a breadth-first manner. This iterative approach avoids recursion stack overflow issues for very large islands.

Brute Force

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

For each unvisited land cell, recursively count all connected land cells. This approach doesn't mark visited cells, leading to redundant counting of the same island multiple times.

Depth-First Search

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

When we find an unvisited land cell, we start a DFS to explore the entire island, marking cells as visited. This ensures each island is counted exactly once.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

High Frequency

~15 min Avg. Time

5.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