• m == grid.length, n == grid[i].length
• 1 <= m, n <= 50
• grid[i][j] is 0 or 1
• Cells touching only at a corner belong to different islands.
• Return 0, not -1 or an error, when there is no land.

This problem sits one small step beyond simply counting islands, and that step is the interesting part. Counting groups needs nothing but the knowledge that a group exists. Measuring them needs each traversal to come back carrying a number. How information travels back out of a recursive walk is the idea worth taking away.

The obvious plan is to stand on every land cell and count how much land connects to it, keeping the biggest result.

best = 0
for r, c in all_cells:
    if grid[r][c] == 1:
        best = max(best, count_connected(r, c))    # a fresh count from every cell

Two things are wrong. The smaller problem is cost: an island of size k triggers k separate counts, each of which walks all k cells, so a single large island costs k² and the grid overall approaches O((m × n)²).

The larger problem is that count_connected does not work at all unless it tracks where it has been. Without that, it walks from a cell to its neighbour and straight back again, forever. And once you add a visited set, you must clear it between starting cells, which is more work again.

Name the waste: every cell of an island independently recomputes the size of the island it belongs to. That size is a property of the island, not of the cell. It should be computed once, when the island is first discovered.

Combine the two jobs. Scan the grid for land not yet seen. Each time you find some, you have found an island nobody has measured yet — so walk it, and while walking, sink every cell you enter so it can never be found again. Count the cells as you sink them. When the walk returns, you have that island's exact area and it can never be counted twice.

The outer scan and the inner walk again have completely separate jobs. The scan finds one new island at a time; the walk consumes and measures exactly one island.

That much mirrors plain island counting. The new part is how the count gets back to the caller.

The walk is recursive, and a recursive call is a function call like any other, which means it can return a value. That is the mechanism for carrying information back out.

Think about what one cell can honestly report. A cell that is water or off the grid contributes nothing, so it reports 0. A land cell contributes itself, worth 1, plus everything its four neighbours report. It does not need to know anything about the island's global shape; it only adds its own 1 to the four numbers handed back to it.

def max_area_of_island(grid):
    rows, cols = len(grid), len(grid[0])

    def area(r, c):
        if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] == 0:
            return 0                     # base case: contributes nothing
        grid[r][c] = 0                   # sink BEFORE recursing
        return (1
                + area(r + 1, c)
                + area(r - 1, c)
                + area(r, c + 1)
                + area(r, c - 1))

    best = 0
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == 1:
                best = max(best, area(r, c))
    return best

That is the whole difference from a plain island count: the traversal returns a number instead of returning nothing, and the caller keeps a running maximum. The skeleton is otherwise unchanged.

Why is the arithmetic correct? Because sinking on entry guarantees each land cell is entered exactly once across the whole traversal, so each cell contributes its 1 to exactly one call's sum. The sums nest — a call's result includes the results of everything below it — and the outermost call therefore totals every cell in the island, once each.

Every cell is entered at most once by a traversal and looked at once by the scan, so the total is O(m × n) time, with recursion depth up to O(m × n) in the worst case of one snaking island.

Grid:

1 1 0
0 0 0
1 1 1

The scan reaches (0,0), which is land, so area(0,0) runs.

The scan continues. (0,1) now reads as water — it was sunk — so it is skipped, which is exactly what stops this island being measured a second time. Row 1 is all water.

The scan finishes over an empty grid. Answer 3.

For the corner-only grid [[1,0,1],[0,0,0],[1,0,1]], each traversal sinks a single cell and finds water in all four directions, so each returns 1 and best stays 1 — even though four land cells exist in total. Area is measured per island, never summed across them.

The skeleton here is the same connected-region traversal used to fill a region or count islands. Only one slot changed: what each traversal reports. That slot is the whole design space.

The underlying principle is worth stating plainly, because it generalises far beyond grids: information travels down a recursion as arguments and travels back up as return values. When each part of a structure must contribute to a total, give the recursive call a return type and let the sums nest. When a decision instead depends on where you came from, pass it down as a parameter. Nearly every tree and graph recursion is one of these two shapes, or both at once.

Recognition signals: largest region, size of each group, total cells in a cluster — any question about a per-component quantity rather than the mere existence of components. Depth-first search is used rather than breadth-first because the question is about totals, not distances; a queue-based version visits identical cells and gives an identical answer, and is the safer choice when the grid is large enough for recursion depth to matter.

Train the reflex: when a problem asks for a property of each group rather than how many groups, keep the same traversal and change what it hands back.