Flood Fill

Flood Fill - Problem

Flood Fill is a classic image processing algorithm that simulates the "paint bucket" tool found in graphics programs like MS Paint or Photoshop.

You're given an image represented as a 2D grid where each cell contains a pixel value (color). Starting from a specified pixel at position (sr, sc), you need to "flood" all connected pixels of the same original color with a new color.

The Process:
1. Start at pixel image[sr][sc] and note its original color
2. Change this pixel to the new color
3. Recursively do the same for all adjacent pixels (up, down, left, right) that have the same original color
4. Stop when no more connected pixels have the original color

Think of it like spilling paint on a connected area - it spreads to all touching pixels of the same color!

Input & Output

example_1.py — Basic Flood Fill

$ 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]]

💡 Note: Starting from center position (1,1) with original color 1, we flood fill with color 2. All connected pixels with value 1 get changed to 2, but the 0s act as boundaries and remain unchanged.

example_2.py — Same Color Edge Case

$ Input: image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, color = 0

› Output: [[0,0,0],[0,0,0]]

💡 Note: The starting pixel already has the target color (0), so no changes are needed. The algorithm returns early to avoid infinite recursion.

example_3.py — Single Pixel

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

› Output: [[3]]

💡 Note: Simple case with just one pixel. The pixel at (0,0) has value 1 and gets changed to 3.

Constraints

m == image.length
n == image[i].length
1 ≤ m, n ≤ 50
0 ≤ image[i][j], color < 2¹⁶
0 ≤ sr < m
0 ≤ sc < n

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 35 f Meta 28 A Adobe 25

The optimal solution uses Depth-First Search (DFS) or Breadth-First Search (BFS) to efficiently traverse only the connected pixels that need to be changed. Both approaches have O(m×n) time complexity and visit each pixel at most once. DFS is simpler with recursion, while BFS avoids recursion stack overflow for large regions. The key insight is to only explore pixels that are actually connected to the starting point and have the original color.

Common Approaches

✓ Sort First

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

Frequency Count

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

Breadth-First Search (BFS) - Iterative

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

This approach uses Breadth-First Search with a queue to iteratively process pixels level by level. It's equivalent to DFS in functionality but uses explicit queue instead of recursion stack, making it safer for very large connected regions.

Brute Force (Repeated Scans)

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

This approach scans the entire image multiple times. In each pass, it looks for pixels adjacent to already-changed pixels that still have the original color and changes them. This continues until a full scan produces no changes.

Depth-First Search (DFS) - Recursive

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

This is the optimal approach using Depth-First Search. Starting from the given position, we recursively explore all 4-directionally connected pixels that have the same original color, changing them to the new color as we go.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

52.8K Views

Medium-High Frequency

~15 min Avg. Time

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