Rotting Oranges - Practice Coding Problems

Rotting Oranges - Problem

Imagine you're managing a fruit storage warehouse where oranges are stored in a rectangular grid. The warehouse has been contaminated, and some oranges have started rotting! 🍊

You are given an m × n grid where each cell can contain:

0 - An empty cell
1 - A fresh orange
2 - A rotten orange

The rot spreads rapidly! Every minute, any fresh orange that is 4-directionally adjacent (up, down, left, right) to a rotten orange becomes rotten.

Your mission: Determine the minimum number of minutes that must elapse until no cell has a fresh orange. If it's impossible for all fresh oranges to rot (some are completely isolated), return -1.

This is a classic multi-source BFS problem - perfect for simulating simultaneous spreading processes!

Input & Output

example_1.py — Standard Grid

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

› Output: 4

💡 Note: The rot spreads from the single rotten orange at (0,0). After 1 minute: (0,1) and (1,0) rot. After 2 minutes: (0,2) and (1,1) rot. After 3 minutes: (2,1) rots. After 4 minutes: (1,2) and (2,2) rot. All fresh oranges are now rotten.

example_2.py — Impossible Case

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

› Output: -1

💡 Note: The orange at position (2,0) is isolated by empty cells and cannot be reached by the rot spreading from (0,0). Since not all fresh oranges can rot, we return -1.

example_3.py — No Fresh Oranges

$ Input: grid = [[2]]

› Output: 0

💡 Note: There are no fresh oranges to rot, so 0 minutes are needed.

Visualization

Tap to expand

Understanding the Visualization

Initial Contamination

Identify all initially contaminated oranges (value 2) and healthy oranges (value 1)

Wave Propagation

Each minute, contamination spreads to adjacent healthy oranges in all 4 directions

Simultaneous Spread

Multiple contamination sources spread simultaneously, creating overlapping infection waves

Completion Check

Process continues until no more healthy oranges can be infected

Key Takeaway

🎯 Key Insight: Multi-source BFS naturally handles simultaneous spreading from multiple points, ensuring we find the minimum time by processing all oranges at the same 'distance' (time) together.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Each cell is visited at most once when it gets rotten

✓ Linear Growth

Space Complexity

O(m × n)

Queue can contain up to all cells in worst case

⚡ Linearithmic Space

Constraints

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

Asked in

a Amazon 42 G Google 38 f Meta 29 ⊞ Microsoft 25 Apple 18

The optimal solution uses Multi-Source BFS to simulate the rotting process. By starting from all initially rotten oranges simultaneously and processing them level by level, we ensure minimum time complexity of O(m×n) where each cell is visited exactly once. The key insight is that BFS naturally processes nodes by distance (time), making it perfect for this time-based spreading problem.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with Nested Loops	O(m × n × t)	O(1)	Repeatedly scan the grid and simulate the rotting process minute by minute
Multi-Source BFS (Optimal)	O(m × n)	O(m × n)	Use BFS starting from all rotten oranges simultaneously to find minimum time

Simulation with Nested Loops — Algorithm Steps

Initialize minutes counter to 0
Repeat until no changes occur in an iteration:
Scan entire grid to find fresh oranges adjacent to rotten ones
Mark these fresh oranges as 'to be rotted'
Apply all rot changes simultaneously
Increment minutes counter
Check if any fresh oranges remain; if yes and no changes occurred, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with the original grid containing fresh and rotten oranges

Scan Grid

Scan entire grid to find fresh oranges adjacent to rotten ones

Mark for Rot

Collect positions of oranges that should rot this minute

Apply Changes

Simultaneously update all marked positions to rotten

Repeat

Continue until no more changes occur

Code -

solution.c — C

int orangesRotting(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int rows = gridSize, cols = gridColSize[0];
    int minutes = 0;
    
    while (1) {
        int toRot[rows * cols][2];
        int toRotCount = 0;
        
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (grid[i][j] == 1) {
                    int directions[4][2] = {{-1,0}, {1,0}, {0,-1}, {0,1}};
                    for (int d = 0; d < 4; d++) {
                        int ni = i + directions[d][0], nj = j + directions[d][1];
                        if (ni >= 0 && ni < rows && nj >= 0 && nj < cols && grid[ni][nj] == 2) {
                            toRot[toRotCount][0] = i;
                            toRot[toRotCount][1] = j;
                            toRotCount++;
                            break;
                        }
                    }
                }
            }
        }
        
        if (toRotCount == 0) break;
        
        for (int i = 0; i < toRotCount; i++) {
            grid[toRot[i][0]][toRot[i][1]] = 2;
        }
        
        minutes++;
    }
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (grid[i][j] == 1) return -1;
        }
    }
    
    return minutes;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × t)

We scan the m×n grid up to t times, where t is the maximum time needed

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

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

68.4K Views

High Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulation with Nested Loops — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler