Minimum Moves to Clean the Classroom

Minimum Moves to Clean the Classroom - Problem

You are given an m x n grid classroom where a student volunteer is tasked with cleaning up litter scattered around the room.

Each cell in the grid is one of the following:

'S': Starting position of the student
'L': Litter that must be collected (once collected, the cell becomes empty)
'R': Reset area that restores the student's energy to full capacity, regardless of their current energy level (can be used multiple times)
'X': Obstacle the student cannot pass through
'.': Empty space

You are also given an integer energy, representing the student's maximum energy capacity. The student starts with this energy from the starting position 'S'.

Each move to an adjacent cell (up, down, left, or right) costs 1 unit of energy. If the energy reaches 0, the student can only continue if they are on a reset area 'R', which resets the energy to its maximum capacity energy.

Return the minimum number of moves required to collect all litter items, or -1 if it's impossible.

Input & Output

Example 1 — Basic Classroom

$ Input: classroom = [["S","L","R"],[".","X","L"]], energy = 3

› Output: 3

💡 Note: Start at (0,0), collect litter at (0,1) in 1 move, go to reset at (0,2) in 1 move to restore energy, then move to (1,2) to collect second litter in 1 move. Total: 3 moves.

Example 2 — No Litter

$ Input: classroom = [["S",".","R"],[".","X","."]], energy = 2

› Output: 0

💡 Note: No litter to collect, so 0 moves required.

Example 3 — Impossible Case

$ Input: classroom = [["S","X","L"]], energy = 1

› Output: -1

💡 Note: Cannot reach the litter at (0,2) because obstacle at (0,1) blocks the path and we don't have enough energy to go around.

Constraints

1 ≤ m, n ≤ 20
1 ≤ energy ≤ 20
The grid contains exactly one 'S'
The number of 'L' cells is at most 10

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to use BFS with state tracking where each state includes position, collected litter bitmask, and current energy. The optimal approach is BFS with state encoding to ensure minimum moves. Time: O(m×n×2^L×E), Space: O(m×n×2^L×E).

Common Approaches

✓ BFS with State Tracking

⏱️ Time: O(m×n×2^L×E) Space: O(m×n×2^L×E)

Use breadth-first search where each state includes current position, which litter items have been collected (using bitmask), and current energy level. This ensures we find the minimum number of moves.

Brute Force DFS with Backtracking

⏱️ Time: O(L! × 4^(m×n)) Space: O(m×n)

Explore every possible sequence of moves using depth-first search, trying all permutations of visiting litter items. Use backtracking to undo moves and try different paths.

BFS with State Tracking — Algorithm Steps

Encode state as (position, collected_mask, energy)
Use BFS to explore all reachable states
Track visited states to avoid cycles
Return moves when all litter collected

Visualization

Tap to expand

Step-by-Step Walkthrough

Encode State

State = (position, collected_mask, energy)

BFS Exploration

Explore all reachable states level by level

Track Progress

Use bitmask to track which litter items collected

Code -

solution.c — C

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

typedef struct {
    int x, y, mask, energy, moves;
} State;

static char classroom[20][20];
static State queue[100000];
static int visited[20][20][1024][21]; // [x][y][mask][energy]

int solution(int m, int n, int energy) {
    int startX = -1, startY = -1;
    int litterPositions[20][2];
    int litterCount = 0;
    
    // Reset visited array
    memset(visited, 0, sizeof(visited));
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (classroom[i][j] == 'S') {
                startX = i;
                startY = j;
            } else if (classroom[i][j] == 'L') {
                litterPositions[litterCount][0] = i;
                litterPositions[litterCount][1] = j;
                litterCount++;
            }
        }
    }
    
    if (litterCount == 0) return 0;
    
    int targetMask = (1 << litterCount) - 1;
    
    int front = 0, rear = 0;
    queue[rear++] = (State){startX, startY, 0, energy, 0};
    
    int dirs[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    
    while (front < rear) {
        State curr = queue[front++];
        
        if (curr.mask == targetMask) {
            return curr.moves;
        }
        
        if (visited[curr.x][curr.y][curr.mask][curr.energy]) continue;
        visited[curr.x][curr.y][curr.mask][curr.energy] = 1;
        
        for (int d = 0; d < 4; d++) {
            int nx = curr.x + dirs[d][0];
            int ny = curr.y + dirs[d][1];
            
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && classroom[nx][ny] != 'X') {
                int newEnergy = curr.energy - 1;
                int newMask = curr.mask;
                
                // Check if this is a litter position
                for (int i = 0; i < litterCount; i++) {
                    if (nx == litterPositions[i][0] && ny == litterPositions[i][1]) {
                        newMask |= (1 << i);
                        break;
                    }
                }
                
                // Recharge station
                if (classroom[nx][ny] == 'R') {
                    newEnergy = energy;
                }
                
                // Can only move if we have energy
                if (newEnergy >= 0 && rear < 100000 && !visited[nx][ny][newMask][newEnergy]) {
                    queue[rear++] = (State){nx, ny, newMask, newEnergy, curr.moves + 1};
                }
            }
        }
    }
    
    return -1;
}

int main() {
    char line[2000];
    fgets(line, sizeof(line), stdin);
    
    // Parse classroom array from JSON format
    int m = 0, n = 0;
    char *ptr = line;
    
    // Find first [
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return -1;
    ptr++; // Skip first [
    
    // Parse each row
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n' || *ptr == ',')) ptr++;
        
        if (*ptr == '[') {
            ptr++; // Skip row opening bracket
            n = 0;
            
            // Parse elements in this row
            while (*ptr && *ptr != ']') {
                // Skip whitespace and commas
                while (*ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == ',')) ptr++;
                
                if (*ptr == '"') {
                    ptr++; // Skip opening quote
                    if (*ptr && *ptr != '"') {
                        classroom[m][n++] = *ptr;
                        ptr++;
                    }
                    if (*ptr == '"') ptr++; // Skip closing quote
                }
            }
            if (*ptr == ']') ptr++; // Skip row closing bracket
            m++;
        }
    }
    
    int energy;
    scanf("%d", &energy);
    
    int result = solution(m, n, energy);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×2^L×E)

BFS visits each cell with each possible combination of collected litter (2^L) and energy levels (E)

✓ Linear Growth

Space Complexity

O(m×n×2^L×E)

Store visited states for each position, litter collection mask, and energy level

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

BFS with State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler