Sliding Puzzle

Sliding Puzzle - Problem

Array Dynamic Programming Backtracking Breadth-First Search Memoization Matrix Hard

On a 2 x 3 board, there are five tiles labeled from 1 to 5, and an empty square represented by 0.

A move consists of choosing 0 and a 4-directionally adjacent number and swapping it.

The state of the board is solved if and only if the board is [[1,2,3],[4,5,0]].

Given the puzzle board, return the least number of moves required so that the state of the board is solved. If it is impossible for the state of the board to be solved, return -1.

Input & Output

Example 1 — Basic Case

$ Input: board = [[1,2,3],[4,0,5]]

› Output: 1

💡 Note: Swap the 0 and the 5 in one move: [[1,2,3],[4,0,5]] → [[1,2,3],[4,5,0]]

Example 2 — Multiple Moves

$ Input: board = [[1,2,3],[5,4,0]]

› Output: -1

💡 Note: No number of moves will make the board solved. The puzzle is unsolvable.

Example 3 — Already Solved

$ Input: board = [[1,2,3],[4,5,0]]

› Output: 0

💡 Note: The board is already in the solved state, so 0 moves are needed.

Constraints

board.length == 2
board[i].length == 3
0 ≤ board[i][j] ≤ 5
Each value board[i][j] is unique

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to treat each board state as a node in a graph and find the shortest path to the target state. The best approach is BFS which guarantees minimum moves. Time: O(6!), Space: O(6!)

Common Approaches

✓ BFS - Shortest Path

⏱️ Time: O(6!) Space: O(6!)

Convert board states to strings and use BFS to explore all reachable states level by level. This guarantees finding the minimum number of moves to reach the target state.

Brute Force DFS

⏱️ Time: O(6!) Space: O(6!)

Generate all possible board states by recursively trying every valid move. Keep track of visited states to avoid cycles and find any path to the solution.

BFS - Shortest Path — Algorithm Steps

Convert initial board to string
Use queue for BFS traversal
Generate all valid neighbor states
Track visited states to avoid cycles
Return moves when target found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start State

Add initial board to queue

Level 1

Explore all states reachable in 1 move

Continue

Keep expanding until target found

Code -

solution.c — C

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

#define MAX_QUEUE 1000

typedef struct {
    char state[7];
    int moves;
} QueueItem;

void getNeighbors(const char* state, char neighbors[][7], int* count) {
    *count = 0;
    int zeroIdx = strchr(state, '0') - state;
    int row = zeroIdx / 3;
    int col = zeroIdx % 3;
    
    int directions[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    
    for (int i = 0; i < 4; i++) {
        int newRow = row + directions[i][0];
        int newCol = col + directions[i][1];
        if (newRow >= 0 && newRow < 2 && newCol >= 0 && newCol < 3) {
            int newIdx = newRow * 3 + newCol;
            strcpy(neighbors[*count], state);
            char temp = neighbors[*count][zeroIdx];
            neighbors[*count][zeroIdx] = neighbors[*count][newIdx];
            neighbors[*count][newIdx] = temp;
            (*count)++;
        }
    }
}

int isVisited(char visited[][7], int visitedCount, const char* state) {
    for (int i = 0; i < visitedCount; i++) {
        if (strcmp(visited[i], state) == 0) {
            return 1;
        }
    }
    return 0;
}

int solution(int board[2][3]) {
    char target[] = "123450";
    char start[7] = {0};
    
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            start[i * 3 + j] = '0' + board[i][j];
        }
    }
    
    if (strcmp(start, target) == 0) return 0;
    
    QueueItem queue[MAX_QUEUE];
    char visited[MAX_QUEUE][7];
    int front = 0, rear = 0, visitedCount = 0;
    
    strcpy(queue[rear].state, start);
    queue[rear].moves = 0;
    rear++;
    strcpy(visited[visitedCount++], start);
    
    while (front < rear) {
        QueueItem current = queue[front++];
        
        char neighbors[4][7];
        int count;
        getNeighbors(current.state, neighbors, &count);
        
        for (int i = 0; i < count; i++) {
            if (strcmp(neighbors[i], target) == 0) {
                return current.moves + 1;
            }
            
            if (!isVisited(visited, visitedCount, neighbors[i])) {
                strcpy(visited[visitedCount++], neighbors[i]);
                strcpy(queue[rear].state, neighbors[i]);
                queue[rear].moves = current.moves + 1;
                rear++;
            }
        }
    }
    
    return -1;
}

int main() {
    int board[2][3];
    char line[100];
    fgets(line, sizeof(line), stdin);
    
    sscanf(line, "[[%d,%d,%d],[%d,%d,%d]]", 
           &board[0][0], &board[0][1], &board[0][2],
           &board[1][0], &board[1][1], &board[1][2]);
    
    printf("%d\n", solution(board));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(6!)

At most 6! = 720 possible board configurations to explore

✓ Linear Growth

Space Complexity

O(6!)

Queue and visited set can store up to 720 states

✓ Linear Space

89.0K Views

Medium Frequency

~25 min Avg. Time

2.3K 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 - Shortest Path — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler