How do you approach Flood Fill?

If the starting pixel already equals the new color, return immediately to avoid infinite recursion.

What are common mistakes on Flood Fill?

Building the adjacency list in one direction on an undirected graph. Assuming the graph is connected. Most inputs allow several components, and one traversal from node 0 misses the rest. Ignoring self-loops and parallel edges when the constraints allow them.

gitGood.dev

← Back to problems

Flood Fill

MediumAlgorithms

Description

You are given an image represented by an m x n grid of integers. You are also given a starting pixel (sr, sc) and a new color.

Perform a flood fill: starting from (sr, sc), change the color of that pixel and every 4-directionally connected pixel of the same original color to color. Return the modified image.

Example 1

Input: image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, color = 2

Output: [[2,2,2],[2,2,0],[2,0,1]]

Explanation: All 1s connected to the center become 2.

Constraints

- m == image.length - n == image[i].length - 1 <= m, n <= 50 - 0 <= image[i][j], color < 2^16

Flood Fill: approach, complexity and pitfalls

A medium graphs problem, graded against 7 test cases (5 of them hidden).

The pattern: Graphs

Nodes and edges - traversal, connectivity, cycles, and shortest paths.

Reach for it when you see: Explicit edges, a grid treated as a graph, or dependencies between items.

If you are stuck

Show the 2-step hint ladder

If the starting pixel already equals the new color, return immediately to avoid infinite recursion.
DFS into neighbors that match the original color.

The optimal approach

Show the approach: The approach

DFS from the source. Capture the original color first. If it already equals the target, return the image unchanged (this prevents an infinite loop). Otherwise recolor and recurse into matching neighbors.

Time: O(m·n). Space: O(m·n) recursion.

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.
Zero. Zero appears in the input, which is the value most likely to break a truthiness check used in place of an explicit comparison.

Common Graphs mistakes

These apply to the pattern as a whole, not just this problem.

Building the adjacency list in one direction on an undirected graph.
Assuming the graph is connected. Most inputs allow several components, and one traversal from node 0 misses the rest.
Ignoring self-loops and parallel edges when the constraints allow them.