Robot Room Cleaner - Practice Coding Problems

Robot Room Cleaner - Problem

Backtracking Interactive Hard

You control a cleaning robot in an unknown room layout! 🤖 The robot starts at an unknown position in a room represented as a binary grid where 0 = wall and 1 = empty space. Your mission: clean every accessible cell using only these blind navigation commands:

Available Robot API:

move() - Move forward if possible, returns true/false
turnLeft() - Rotate 90° counterclockwise
turnRight() - Rotate 90° clockwise
clean() - Clean current cell

The Challenge: You have no map, no coordinates, no sensors - just these four commands! The robot initially faces UP and is guaranteed to start in an empty cell. All room edges are surrounded by walls.

This is a classic "blind exploration" problem that tests your ability to systematically traverse an unknown space using backtracking algorithms.

Input & Output

example_1.py — Simple 3x3 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]], robot starts at (1,3)

› Output: Robot cleans all accessible cells: (0,0),(0,1),(0,2),(0,3),(0,4),(0,6),(0,7),(1,0),(1,1),(1,2),(1,3),(1,4),(1,6),(1,7),(2,0),(2,2),(2,3),(2,4),(2,5),(2,6),(2,7),(4,0),(4,1),(4,2),(4,3),(4,4),(4,5),(4,6),(4,7)

💡 Note: The DFS algorithm systematically explores all reachable cells. Starting from (1,3), it uses virtual coordinates and explores up, right, down, left directions recursively, backtracking when hitting walls or visited cells. All empty cells (marked as 1) get cleaned exactly once.

example_2.py — L-shaped Room

$ Input: room = [[1,1,0],[1,1,1],[1,0,1]], robot starts at (1,1)

› Output: Robot cleans: (0,0),(0,1),(1,0),(1,1),(1,2),(2,0),(2,2)

💡 Note: In this L-shaped room, the robot starts at the center and systematically explores all connected empty cells. The backtracking ensures it returns to explore all branches of the L-shape, cleaning each accessible cell exactly once.

example_3.py — Single Cell Room

$ Input: room = [[1]], robot starts at (0,0)

› Output: Robot cleans: (0,0)

💡 Note: Edge case with only one cell. The robot cleans the starting position and finds no valid moves in any direction, completing successfully with 100% coverage of the single accessible cell.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Robot starts at unknown position (0,0 in virtual coordinates), creates visited set, begins facing UP

Clean Current

Clean current cell and mark coordinates as visited in our tracking set

Try All Directions

Systematically try each direction: UP (0°), RIGHT (90°), DOWN (180°), LEFT (270°)

Explore or Skip

If cell unvisited and move succeeds → recurse; if wall/visited → turn to next direction

Backtrack

After exploring a direction, turn 180°, move back, turn 180° to restore position/orientation

Complete

Continue until all directions tried from all reachable positions - guaranteed complete coverage!

Key Takeaway

🎯 Key Insight: Transform the unknown physical space into a logical coordinate system, then use systematic DFS traversal with backtracking to guarantee complete coverage - like a methodical explorer who never gets lost!

Time & Space Complexity

Time Complexity

⏱️

O(N - M)

Where N is total cells and M is walls. We visit each empty cell exactly once, with constant time backtracking operations

✓ Linear Growth

Space Complexity

O(N - M)

Space for visited set storing all empty cells, plus O(N-M) recursion stack in worst case (straight line room)

✓ Linear Space

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 of the robot
Robot starts at an empty cell (room[row][col] = 1)
You cannot access the room matrix directly - must use Robot API only

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses DFS with backtracking and virtual coordinates. We systematically explore all four directions (up, right, down, left) from each position, using a visited set to track cleaned cells. After exploring each direction, we backtrack by turning 180°, moving back, and turning 180° again. This guarantees complete coverage of all reachable cells in O(N-M) time where N is total cells and M is walls.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Backtracking (Optimal)	O(N - M)	O(N - M)	Systematic exploration using DFS with virtual coordinates and visited tracking
Random Walk Approach	O(∞)	O(1)	Randomly try directions until all areas are hopefully covered

DFS with Backtracking (Optimal) — Algorithm Steps

Initialize virtual coordinates (0,0) and direction (facing up)
Create visited set to track cleaned positions
For each cell: clean it and mark as visited
Try all 4 directions in order: up, right, down, left
If move successful and cell unvisited, recursively explore
After exploring each direction, backtrack: turn 180°, move back, turn 180° again
Continue until all reachable cells are cleaned

Visualization

Tap to expand

Step-by-Step Walkthrough

Start & Clean

Begin at (0,0), clean current cell, mark as visited

Try Directions

Systematically try up, right, down, left in order

Recursive Explore

When move succeeds, recursively explore new position

Backtrack

After exploring, return to previous position and try next direction

Complete Coverage

Continue until all reachable cells are cleaned exactly once

Code -

solution.c — C

// Robot Room Cleaner - DFS with Backtracking (Optimal)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_CELLS 10000
#define MAX_KEY_LEN 20

struct VisitedSet {
    char keys[MAX_CELLS][MAX_KEY_LEN];
    int size;
};

struct Solution {
    struct VisitedSet visited;
    int directions[4][2]; // up, right, down, left
};

bool containsKey(struct VisitedSet* set, const char* key) {
    for (int i = 0; i < set->size; i++) {
        if (strcmp(set->keys[i], key) == 0) {
            return true;
        }
    }
    return false;
}

void addKey(struct VisitedSet* set, const char* key) {
    if (set->size < MAX_CELLS) {
        strcpy(set->keys[set->size], key);
        set->size++;
    }
}

void goBack(Robot* robot) {
    // Turn around (180 degrees)
    robotTurnRight(robot);
    robotTurnRight(robot);
    // Move back
    robotMove(robot);
    // Turn around again to face original direction
    robotTurnRight(robot);
    robotTurnRight(robot);
}

void backtrack(struct Solution* sol, Robot* robot, int row, int col, int direction) {
    // Clean current cell and mark as visited
    robotClean(robot);
    char key[MAX_KEY_LEN];
    snprintf(key, sizeof(key), "%d,%d", row, col);
    addKey(&sol->visited, key);
    
    // Try all 4 directions
    for (int i = 0; i < 4; i++) {
        int newRow = row + sol->directions[direction][0];
        int newCol = col + sol->directions[direction][1];
        char newKey[MAX_KEY_LEN];
        snprintf(newKey, sizeof(newKey), "%d,%d", newRow, newCol);
        
        // If cell is not visited and robot can move
        if (!containsKey(&sol->visited, newKey) && robotMove(robot)) {
            // Recursively clean the new cell
            backtrack(sol, robot, newRow, newCol, direction);
            // Backtrack: return to previous cell
            goBack(robot);
        }
        
        // Turn right to try next direction
        robotTurnRight(robot);
        direction = (direction + 1) % 4;
    }
}

void cleanRoom(Robot* robot) {
    struct Solution sol = {
        .visited = {.size = 0},
        .directions = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}
    };
    
    backtrack(&sol, robot, 0, 0, 0);
}

// Example MockRobot struct for testing
struct MockRobot {
    int** room;
    int rows, cols;
    int row, col;
    int direction; // 0: up, 1: right, 2: down, 3: left
    int directions[4][2];
    struct VisitedSet cleaned;
};

struct MockRobot* createMockRobot(int** room, int rows, int cols, int startRow, int startCol) {
    struct MockRobot* robot = malloc(sizeof(struct MockRobot));
    robot->room = room;
    robot->rows = rows;
    robot->cols = cols;
    robot->row = startRow;
    robot->col = startCol;
    robot->direction = 0;
    int dirs[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    memcpy(robot->directions, dirs, sizeof(dirs));
    robot->cleaned.size = 0;
    return robot;
}

void mockClean(struct MockRobot* robot) {
    char key[MAX_KEY_LEN];
    snprintf(key, sizeof(key), "%d,%d", robot->row, robot->col);
    addKey(&robot->cleaned, key);
}

bool mockMove(struct MockRobot* robot) {
    int newRow = robot->row + robot->directions[robot->direction][0];
    int newCol = robot->col + robot->directions[robot->direction][1];
    
    if (newRow >= 0 && newRow < robot->rows &&
        newCol >= 0 && newCol < robot->cols &&
        robot->room[newRow][newCol] == 1) {
        robot->row = newRow;
        robot->col = newCol;
        return true;
    }
    return false;
}

void mockTurnLeft(struct MockRobot* robot) {
    robot->direction = (robot->direction - 1 + 4) % 4;
}

void mockTurnRight(struct MockRobot* robot) {
    robot->direction = (robot->direction + 1) % 4;
}

Time & Space Complexity

Time Complexity

⏱️

O(N - M)

Where N is total cells and M is walls. We visit each empty cell exactly once, with constant time backtracking operations

✓ Linear Growth

Space Complexity

O(N - M)

Space for visited set storing all empty cells, plus O(N-M) recursion stack in worst case (straight line room)

✓ Linear Space

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 of the robot
Robot starts at an empty cell (room[row][col] = 1)
You cannot access the room matrix directly - must use Robot API only

73.5K Views

Medium-High Frequency

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

DFS with Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler