Number of Spaces Cleaning Robot Cleaned - Practice Coding Problems

Number of Spaces Cleaning Robot Cleaned - Problem

Imagine a robotic vacuum cleaner navigating through your room! 🤖

You're given a 2D binary matrix room where 0 represents an empty space and 1 represents a space with an object (like furniture). A cleaning robot starts at the top-left corner (0,0) facing right.

The robot follows a simple algorithm:
• Move straight until it hits an object or room boundary
• Turn 90 degrees clockwise
• Repeat this process indefinitely

Every space the robot visits gets cleaned. Your task is to determine how many unique spaces will be cleaned if the robot runs forever.

Note: The top-left corner (0,0) is always empty in test cases.

Input & Output

example_1.py — Python

$ Input: room = [[0,0,0],[0,1,0],[0,0,0]]

› Output: 7

💡 Note: Robot starts at (0,0) and moves: right to (0,1), right to (0,2), down to (1,2), down to (2,2), left to (2,1), left to (2,0), up to (1,0), then cycles. All 7 empty spaces get cleaned.

example_2.py — Python

$ Input: room = [[0,1,0],[1,0,1],[0,1,0]]

› Output: 1

💡 Note: Robot starts at (0,0) but is immediately blocked by obstacles in all directions after first turn. Only the starting position (0,0) gets cleaned.

example_3.py — Python

$ Input: room = [[0,0],[0,0]]

› Output: 4

💡 Note: In a 2x2 empty room, robot visits all 4 positions: starts at (0,0), goes to (0,1), then (1,1), then (1,0), and cycles back. All positions get cleaned.

Visualization

Tap to expand

Understanding the Visualization

Start Position

Robot begins at top-left corner (0,0) facing right

Forward Movement

Robot moves forward in current direction until blocked

Right Turn

When blocked, robot turns 90° clockwise

Cycle Detection

Track (position, direction) pairs to detect when robot repeats a state

Key Takeaway

🎯 Key Insight: The robot will eventually return to a previously visited (position, direction) state, creating a cycle. We only need to simulate until this cycle is detected!

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

In worst case, robot visits all m×n positions multiple times before entering cycle

✓ Linear Growth

Space Complexity

O(m×n)

Need to store visited positions and state history

⚡ Linearithmic Space

Constraints

1 ≤ room.length, room[i].length ≤ 300
room[i][j] is either 0 or 1
room[0][0] == 0 (starting position is always empty)
The room is surrounded by walls (implicit boundary)

Asked in

G Google 42 a Amazon 38 f Meta 31 Apple 24

The optimal approach is to simulate the robot's movement while tracking visited positions and detecting cycles. Use a set for unique positions and track (position, direction) states to identify when the robot enters a repeating pattern. Time complexity is O(m×n) as each cell can be visited at most 4 times (once per direction).

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with Set Tracking	O(m×n)	O(m×n)	Simulate the robot's movement and track all visited positions

Simulation with Set Tracking — Algorithm Steps

Start at position (0,0) facing right
Keep a set of visited positions for counting
Keep track of (position, direction) states to detect cycles
Move forward until hitting obstacle or boundary
Turn 90 degrees clockwise
Repeat until we detect a cycle
Return the count of unique positions visited

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Robot starts at (0,0) facing right

Move Forward

Robot moves right until hitting obstacle or boundary

Turn Right

Robot turns 90° clockwise when blocked

Repeat Process

Continue until cycle is detected

Code -

solution.c — C

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

#define MAX_STATES 10000

struct State {
    int r, c, dir;
};

struct Position {
    int r, c;
};

int robotSim(int** room, int rows, int cols) {
    // Directions: right, down, left, up
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int dirIdx = 0; // Start facing right
    
    int r = 0, c = 0; // Start position
    struct Position visited[MAX_STATES];
    struct State states[MAX_STATES];
    int visitedCount = 0, stateCount = 0;
    
    while (1) {
        // Check if current state exists
        int found = 0;
        for (int i = 0; i < stateCount; i++) {
            if (states[i].r == r && states[i].c == c && states[i].dir == dirIdx) {
                found = 1;
                break;
            }
        }
        if (found) break;
        
        // Add current state
        states[stateCount].r = r;
        states[stateCount].c = c;
        states[stateCount].dir = dirIdx;
        stateCount++;
        
        // Check if position already visited
        int posFound = 0;
        for (int i = 0; i < visitedCount; i++) {
            if (visited[i].r == r && visited[i].c == c) {
                posFound = 1;
                break;
            }
        }
        if (!posFound) {
            visited[visitedCount].r = r;
            visited[visitedCount].c = c;
            visitedCount++;
        }
        
        // Try to move forward
        int dr = directions[dirIdx][0], dc = directions[dirIdx][1];
        int nr = r + dr, nc = c + dc;
        
        // Check if we can move forward
        if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && room[nr][nc] == 0) {
            r = nr;
            c = nc;
        } else {
            // Turn 90 degrees clockwise
            dirIdx = (dirIdx + 1) % 4;
        }
    }
    
    return visitedCount;
}

int main() {
    // Example usage
    int* room[3];
    int row0[] = {0, 0, 0};
    int row1[] = {0, 1, 0};
    int row2[] = {0, 0, 0};
    room[0] = row0; room[1] = row1; room[2] = row2;
    
    printf("%d\n", robotSim(room, 3, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

In worst case, robot visits all m×n positions multiple times before entering cycle

✓ Linear Growth

Space Complexity

O(m×n)

Need to store visited positions and state history

⚡ Linearithmic Space

Constraints

1 ≤ room.length, room[i].length ≤ 300
room[i][j] is either 0 or 1
room[0][0] == 0 (starting position is always empty)
The room is surrounded by walls (implicit boundary)

28.5K Views

Medium Frequency

~18 min Avg. Time

892 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 Set Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler