Minimum Moves to Clean the Classroom - Practice Coding Problems

Minimum Moves to Clean the Classroom - Problem

Classroom Cleanup Challenge

You're helping a volunteer student clean up a classroom represented by an m x n grid. The student needs to collect all scattered litter while managing their limited energy.

Grid Elements:
• 'S' - Starting position of the student
• 'L' - Litter to be collected (becomes empty after collection)
• 'R' - Reset stations that restore energy to full capacity
• 'X' - Obstacles that block movement
• '.' - Empty walkable spaces

Movement Rules:
• Move up, down, left, or right to adjacent cells
• Each move costs 1 energy unit
• Student starts with energy units of energy
• When energy reaches 0, student can only continue from a reset station 'R'
• Reset stations can be used multiple times

Goal: Find the minimum number of moves to collect all litter, or return -1 if impossible.

Input & Output

example_1.py — Basic classroom with litter

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

› Output: 6

💡 Note: Start at (0,0) with energy 3. Move right to (0,1) with energy 2, then down to (1,1) blocked by X. Must go (0,0)→(0,2) collect L→(1,2)→(2,2) collect L→(2,1)→(2,0) reset energy→explore to collect remaining litter. Total: 6 moves.

example_2.py — Energy management required

$ Input: classroom = [['S', '.', '.', 'R'], ['.', 'L', '.', '.'], ['.', '.', 'L', '.']], energy = 2

› Output: 8

💡 Note: With only 2 energy, must strategically use reset station at (0,3). Path: S→R (restore)→collect litter optimally. The limited energy forces multiple trips to the reset station.

example_3.py — Impossible scenario

$ Input: classroom = [['S', 'X'], ['X', 'L']], energy = 5

› Output: -1

💡 Note: The litter at (1,1) is completely blocked by obstacles. No path exists from S to L, making it impossible to clean all litter regardless of energy level.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Robot starts at position S with full battery

Explore

Robot moves in all directions, consuming energy per move

Collect

When robot finds litter L, it collects it automatically

Recharge

When battery is low, robot must find reset station R

Complete

Mission accomplished when all litter is collected

Key Takeaway

🎯 Key Insight: This problem combines shortest path finding with resource management (energy) and state tracking (collected items), making BFS with state compression the optimal approach.

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, we explore 4 directions for each of m*n cells, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack depth limited by grid size in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 10
1 ≤ energy ≤ 20
The grid contains exactly one 'S'
Number of 'L' cells ≤ 10
Number of 'R' cells ≥ 0
Grid cells are only 'S', 'L', 'R', 'X', or '.'

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses BFS with state tracking where each state represents (position, energy, collected_litter_bitmask). This guarantees finding the minimum number of moves while efficiently handling energy constraints and litter collection using bit manipulation for state compression.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force DFS with Backtracking	O(4^(m*n))	O(m*n)	Try all possible paths using recursive DFS to collect all litter
BFS with State Tracking (Optimal)	O(mnenergy*2^L)	O(mnenergy*2^L)	Use BFS with (position, energy, collected_litter) state to find shortest path

Brute Force DFS with Backtracking — Algorithm Steps

Start from position 'S' with full energy
For each valid adjacent cell, recursively explore that path
Track energy consumption and restore at reset stations
Collect litter when encountered and mark as collected
Backtrack when energy runs out or path becomes invalid
Return minimum moves among all successful paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at 'S' with full energy

Explore Paths

Try each direction recursively

Collect Litter

Mark litter as collected when visited

Backtrack

Return when energy runs out or all paths explored

Code -

solution.c — C

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

int dfs(char** classroom, int m, int n, int x, int y, int currentEnergy, int energy, int* collected, int moves, int totalLitter, int collectedCount) {
    if (collectedCount == totalLitter) {
        return moves;
    }
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    int minMoves = INT_MAX;
    
    for (int i = 0; i < 4; i++) {
        int nx = x + directions[i][0];
        int ny = y + directions[i][1];
        
        if (nx >= 0 && nx < m && ny >= 0 && ny < n && classroom[nx][ny] != 'X') {
            int newEnergy = currentEnergy - 1;
            
            if (newEnergy < 0) continue;
            
            int* newCollected = (int*)malloc(m * n * sizeof(int));
            memcpy(newCollected, collected, m * n * sizeof(int));
            
            int actualEnergy = newEnergy;
            int newCollectedCount = collectedCount;
            
            if (classroom[nx][ny] == 'L' && !collected[nx * n + ny]) {
                newCollected[nx * n + ny] = 1;
                newCollectedCount++;
            } else if (classroom[nx][ny] == 'R') {
                actualEnergy = energy;
            }
            
            if (actualEnergy == 0 && classroom[nx][ny] != 'R') {
                free(newCollected);
                continue;
            }
            
            int result = dfs(classroom, m, n, nx, ny, actualEnergy, energy, newCollected, moves + 1, totalLitter, newCollectedCount);
            free(newCollected);
            
            if (result != -1 && result < minMoves) {
                minMoves = result;
            }
        }
    }
    
    return minMoves == INT_MAX ? -1 : minMoves;
}

int minMovesToCleanClassroom(char** classroom, int classroomSize, int* classroomColSize, int energy) {
    int m = classroomSize, n = classroomColSize[0];
    int startX = -1, startY = -1, totalLitter = 0;
    
    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') {
                totalLitter++;
            }
        }
    }
    
    if (totalLitter == 0) return 0;
    
    int* collected = (int*)calloc(m * n, sizeof(int));
    int result = dfs(classroom, m, n, startX, startY, energy, energy, collected, 0, totalLitter, 0);
    free(collected);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, we explore 4 directions for each of m*n cells, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack depth limited by grid size in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ m, n ≤ 10
1 ≤ energy ≤ 20
The grid contains exactly one 'S'
Number of 'L' cells ≤ 10
Number of 'R' cells ≥ 0
Grid cells are only 'S', 'L', 'R', 'X', or '.'

28.5K Views

Medium Frequency

~18 min Avg. Time

847 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

Brute Force DFS with Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler