Robot Room Cleaner

Robot Room Cleaner - Problem

Backtracking Interactive Hard

You are controlling a robot that is located somewhere in a room. The room is modeled as an m x n binary grid where 0 represents a wall and 1 represents an empty slot.

The robot starts at an unknown location in the room that is guaranteed to be empty, and you do not have access to the grid, but you can move the robot using the given API Robot.

You are tasked to use the robot to clean the entire room (i.e., clean every empty cell in the room). The robot with the four given APIs can move forward, turn left, or turn right. Each turn is 90 degrees.

When the robot tries to move into a wall cell, its bumper sensor detects the obstacle, and it stays on the current cell.

Design an algorithm to clean the entire room using the following APIs:

Interface Robot:

boolean move() - returns true if next cell is open and robot moves into the cell. returns false if next cell is obstacle and robot stays on the current cell.
void turnLeft() - Robot will stay on the same cell after calling turnLeft/turnRight. Each turn will be 90 degrees.
void turnRight() - Robot will stay on the same cell after calling turnLeft/turnRight. Each turn will be 90 degrees.
void clean() - Clean the current cell.

Note: The initial direction of the robot will be facing up. You can assume all four edges of the grid are all surrounded by a wall.

Input & Output

Example 1 — Small Room

$ Input: room = [[1,1,1,1,1,0,1,1],[1,1,1,1,1,0,1,1],[1,0,1,1,1,1,1,1],[0,0,0,1,0,0,0,0],[1,1,1,1,1,1,1,1]], row = 1, col = 3

› Output: Robot cleans all reachable cells

💡 Note: Robot starts at (1,3) and systematically visits all connected empty cells using DFS backtracking

Example 2 — Single Cell

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

› Output: Robot cleans the only cell

💡 Note: Trivial case: robot cleans current cell, no moves possible, algorithm terminates

Example 3 — L-shaped Room

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

› Output: Robot cleans all 5 reachable cells

💡 Note: Robot navigates L-shape by exploring all directions and backtracking when blocked

Constraints

m == room.length
n == room[i].length
1 ≤ m, n ≤ 100
room[i][j] is either 0 or 1
All the empty cells can be visited from the starting position

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 a Amazon 25 M Microsoft 20

The key insight is to use DFS backtracking with relative coordinate tracking to systematically explore every reachable cell exactly once. The optimal approach uses a visited set and four-directional exploration with backtracking. Time: O(N), Space: O(N) where N is the number of empty cells.

Common Approaches

✓ Random Exploration

⏱️ Time: O(∞) Space: O(1)

The robot moves randomly in any available direction, cleaning cells as it encounters them. This approach lacks systematic coverage and may miss cells or get stuck in local areas.

Systematic DFS Backtracking

⏱️ Time: O(N) Space: O(N)

Track visited cells using relative coordinates and use DFS to explore in all four directions. When no unvisited neighbors remain, backtrack to the previous cell and continue exploration.

Random Exploration — Algorithm Steps

Step 1: Clean current cell
Step 2: Try random directions until one works
Step 3: Move and repeat until stuck

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Robot begins at unknown position

Random Move

Try random directions until one works

Problem

May miss cells or never complete

Code -

solution.c — C

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

#define MAX_VISITED 10000

typedef struct {
    int (*move)(void);
    void (*turnLeft)(void);
    void (*turnRight)(void);
    void (*clean)(void);
} Robot;

int mockMove() { return 0; }
void mockTurnLeft() {}
void mockTurnRight() {}
void mockClean() {}

int directions[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // up, right, down, left
char visited[MAX_VISITED][20];
int visitedCount = 0;

int isVisited(int row, int col) {
    char cellKey[20];
    sprintf(cellKey, "%d,%d", row, col);
    for (int i = 0; i < visitedCount; i++) {
        if (strcmp(visited[i], cellKey) == 0) {
            return 1;
        }
    }
    return 0;
}

void addVisited(int row, int col) {
    sprintf(visited[visitedCount], "%d,%d", row, col);
    visitedCount++;
}

void goBack(Robot* robot) {
    robot->turnRight();
    robot->turnRight();
    robot->move();
    robot->turnRight();
    robot->turnRight();
}

void backtrack(Robot* robot, int row, int col, int direction) {
    addVisited(row, col);
    robot->clean();
    
    // Explore all 4 directions
    for (int i = 0; i < 4; i++) {
        int newRow = row + directions[direction][0];
        int newCol = col + directions[direction][1];
        
        if (!isVisited(newRow, newCol) && robot->move()) {
            backtrack(robot, newRow, newCol, direction);
            goBack(robot);
        }
        
        // Turn clockwise
        robot->turnRight();
        direction = (direction + 1) % 4;
    }
}

void solution(Robot* robot) {
    visitedCount = 0;
    backtrack(robot, 0, 0, 0);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    printf("null\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(∞)

May never terminate or take exponential time

✓ Linear Growth

Space Complexity

O(1)

No additional storage needed

✓ Linear Space

185.0K Views

Medium Frequency

~35 min Avg. Time

2.5K 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

Random Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler