Minimum Moves to Move a Box to Their Target Location - Problem

A storekeeper is a game in which the player pushes boxes around in a warehouse trying to get them to target locations. The game is represented by an m x n grid of characters grid where each element is a wall, floor, or box.

Your task is to move the box 'B' to the target position 'T' under the following rules:

The character 'S' represents the player. The player can move up, down, left, right in grid if it is a floor (empty cell).
The character '.' represents the floor which means a free cell to walk.
The character '#' represents the wall which means an obstacle (impossible to walk there).
There is only one box 'B' and one target cell 'T' in the grid.
The box can be moved to an adjacent free cell by standing next to the box and then moving in the direction of the box. This is a push.
The player cannot walk through the box.

Return the minimum number of pushes to move the box to the target. If there is no way to reach the target, return -1.

Input & Output

Example 1 — Basic Push

$ Input: grid = [["#",".","#"],[".","T","B"],["#","S","#"]]

› Output: 1

💡 Note: Player S can reach position (1,0) to push box B from (1,2) to target T at (1,1) in 1 push

Example 2 — Multiple Pushes

$ Input: grid = [["#","#","#","#","#","#"],["#","T","#","#","#","#"],["#",".",".","B",".","#"],["#",".","#","#",".","#"],["#",".",".",".","S","#"],["#","#","#","#","#","#"]]

› Output: 3

💡 Note: Player must navigate around walls and push box 3 times to reach target

Example 3 — Impossible Case

$ Input: grid = [["#","#","#"],["#","T","#"],["#","B","#"],["#","S","#"]]

› Output: -1

💡 Note: Box is surrounded by walls and cannot be pushed to target

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 20
grid contains only characters '.', '#', 'S', 'B', 'T'
There is only one of each character 'S', 'B', 'T' in the grid

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 12 M Microsoft 6 A Apple 4

The key insight is to model this as a state-space search where each state is (player_position, box_position). Use BFS to guarantee minimum pushes since it explores states level by level. For each push attempt, verify the player can reach the required pushing position using a separate BFS. Time: O(m²×n²), Space: O(m²×n²)

Common Approaches

✓ BFS with State Tracking

⏱️ Time: O(m²*n²) Space: O(m²*n²)

Treat each (player_position, box_position) as a unique state and use BFS to explore all reachable states. This guarantees finding the minimum number of pushes since BFS explores states level by level.

Brute Force DFS

⏱️ Time: O(4^(m*n)) Space: O(m*n)

Use depth-first search to explore all possible sequences of box pushes. For each position, try pushing the box in all four directions if the player can reach the required position.

BFS with State Tracking — Algorithm Steps

Initialize BFS queue with initial (player, box) state
For each state, try pushing box in all four directions
Check if player can reach the required push position
Add new states to queue and continue until target reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with (player_pos, box_pos, 0_pushes)

Try All Pushes

For each direction, check if player can reach push position

Add New States

Add valid (new_player_pos, new_box_pos, pushes+1) to queue

Level by Level

BFS guarantees minimum pushes when target is reached

Code -

solution.c — C

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

#define MAX_SIZE 20
#define MAX_QUEUE 10000

struct State {
    int px, py, bx, by, pushes;
};

struct Queue {
    struct State data[MAX_QUEUE];
    int front, rear;
};

void enqueue(struct Queue* q, struct State s) {
    q->data[q->rear++] = s;
}

struct State dequeue(struct Queue* q) {
    return q->data[q->front++];
}

int isEmpty(struct Queue* q) {
    return q->front >= q->rear;
}

int canReach(char grid[MAX_SIZE][MAX_SIZE], int m, int n, int startX, int startY, int endX, int endY, int boxX, int boxY) {
    if (startX == endX && startY == endY) return 1;
    
    int visited[MAX_SIZE][MAX_SIZE] = {0};
    visited[startX][startY] = 1;
    visited[boxX][boxY] = 1;
    
    struct Queue q = {.front = 0, .rear = 0};
    struct State start = {startX, startY, 0, 0, 0};
    enqueue(&q, start);
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (!isEmpty(&q)) {
        struct State curr = dequeue(&q);
        
        for (int i = 0; i < 4; i++) {
            int nx = curr.px + directions[i][0];
            int ny = curr.py + directions[i][1];
            
            if (nx >= 0 && nx < m && ny >= 0 && ny < n && !visited[nx][ny] && grid[nx][ny] != '#') {
                if (nx == endX && ny == endY) return 1;
                visited[nx][ny] = 1;
                struct State newState = {nx, ny, 0, 0, 0};
                enqueue(&q, newState);
            }
        }
    }
    return 0;
}

int solution(char grid[MAX_SIZE][MAX_SIZE], int m, int n) {
    int px, py, bx, by, tx, ty;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 'S') { px = i; py = j; }
            else if (grid[i][j] == 'B') { bx = i; by = j; }
            else if (grid[i][j] == 'T') { tx = i; ty = j; }
        }
    }
    
    struct Queue q = {.front = 0, .rear = 0};
    int visited[MAX_SIZE][MAX_SIZE][MAX_SIZE][MAX_SIZE] = {0};
    
    struct State initial = {px, py, bx, by, 0};
    enqueue(&q, initial);
    visited[px][py][bx][by] = 1;
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    while (!isEmpty(&q)) {
        struct State curr = dequeue(&q);
        
        if (curr.bx == tx && curr.by == ty) {
            return curr.pushes;
        }
        
        for (int i = 0; i < 4; i++) {
            int newBx = curr.bx + directions[i][0];
            int newBy = curr.by + directions[i][1];
            
            if (newBx >= 0 && newBx < m && newBy >= 0 && newBy < n && grid[newBx][newBy] != '#') {
                int pushFromX = curr.bx - directions[i][0];
                int pushFromY = curr.by - directions[i][1];
                
                if (pushFromX >= 0 && pushFromX < m && pushFromY >= 0 && pushFromY < n &&
                    grid[pushFromX][pushFromY] != '#' &&
                    canReach(grid, m, n, curr.px, curr.py, pushFromX, pushFromY, curr.bx, curr.by) &&
                    !visited[curr.bx][curr.by][newBx][newBy]) {
                    
                    visited[curr.bx][curr.by][newBx][newBy] = 1;
                    struct State newState = {curr.bx, curr.by, newBx, newBy, curr.pushes + 1};
                    enqueue(&q, newState);
                }
            }
        }
    }
    
    return -1;
}

char* parseString(char* str) {
    char* result = malloc(strlen(str) + 1);
    int j = 0;
    for (int i = 0; str[i]; i++) {
        if (str[i] != '"' && str[i] != ' ') {
            result[j++] = str[i];
        }
    }
    result[j] = '\0';
    return result;
}

int main() {
    char line[2000];
    fgets(line, sizeof(line), stdin);
    
    char grid[MAX_SIZE][MAX_SIZE];
    int m = 0, n = 0;
    
    char* cleaned = parseString(line);
    char* ptr = cleaned + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr == ',' || *ptr == '[') {
                    ptr++;
                    continue;
                }
                grid[m][n++] = *ptr;
                ptr++;
            }
            if (*ptr == ']') ptr++;
            if (*ptr == ',') ptr++;
            m++;
        } else {
            ptr++;
        }
    }
    
    free(cleaned);
    printf("%d\n", solution(grid, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²*n²)

Each cell can have player in any position, creating m*n * m*n possible states

⚠ Quadratic Growth

Space Complexity

O(m²*n²)

BFS queue and visited set store up to m²*n² states

⚠ Quadratic Space

23.4K Views

Medium Frequency

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

Minimum Moves to Move a Box to Their Target Location - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS with State Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler