Flood Fill - Practice Coding Problems

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

Understanding the Visualization

Click Starting Pixel

User clicks on a blue pixel with red paint selected

Paint Spreads

Red paint spreads to all connected blue pixels

Boundaries Stop Spread

Yellow pixels act as boundaries - paint doesn't cross them

Filling Complete

All connected blue pixels are now red

Key Takeaway

🎯 Key Insight: Flood fill is like a smart paint bucket that only spreads to connected pixels of the same original color, making it perfect for region-based operations in graphics and image processing.

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

Approach	Time	Space	Notes
✓ Breadth-First Search (BFS) - Iterative	O(m×n)	O(m×n)	Use iterative BFS with a queue to avoid recursion stack limitations
Depth-First Search (DFS) - Recursive	O(m×n)	O(m×n)	Use recursive DFS to efficiently traverse only connected pixels
Brute Force (Repeated Scans)	O(m²×n²)	O(1)	Repeatedly scan the entire grid until no more changes occur

Breadth-First Search (BFS) - Iterative — Algorithm Steps

Check validity and get original color
Return early if original equals new color
Initialize queue with starting position
While queue is not empty: pop pixel, change its color
Add all valid 4-connected neighbors to queue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Add starting position to queue

Process Level 1

Process all pixels at distance 1

Process Level 2

Process all pixels at distance 2

Continue

Continue until queue is empty

Code -

solution.c — C

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

typedef struct {
    int r, c;
} Point;

typedef struct {
    Point* data;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (Point*)malloc(capacity * sizeof(Point));
    q->front = q->rear = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, int r, int c) {
    q->data[q->rear++] = (Point){r, c};
}

Point dequeue(Queue* q) {
    return q->data[q->front++];
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

int** floodFill(int** image, int imageSize, int* imageColSize, int sr, int sc, int color, int* returnSize, int** returnColumnSizes) {
    *returnSize = imageSize;
    *returnColumnSizes = imageColSize;
    
    if (imageSize == 0 || imageColSize[0] == 0) return image;
    
    int m = imageSize, n = imageColSize[0];
    int originalColor = image[sr][sc];
    
    if (originalColor == color) return image;
    
    Queue* queue = createQueue(m * n);
    enqueue(queue, sr, sc);
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    while (!isEmpty(queue)) {
        Point curr = dequeue(queue);
        int r = curr.r, c = curr.c;
        
        // Skip if already processed or out of bounds
        if (r < 0 || r >= m || c < 0 || c >= n || image[r][c] != originalColor) {
            continue;
        }
        
        // Change color
        image[r][c] = color;
        
        // Add neighbors to queue
        for (int i = 0; i < 4; i++) {
            enqueue(queue, r + directions[i][0], c + directions[i][1]);
        }
    }
    
    free(queue->data);
    free(queue);
    return image;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Each pixel is visited at most once, and we process all connected pixels

✓ Linear Growth

Space Complexity

O(m×n)

Queue can contain up to all pixels in worst case (entire grid is connected)

⚡ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search (BFS) - Iterative — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler