Snakes and Ladders

Snakes and Ladders - Problem

You are given an n x n integer matrix board where the cells are labeled from 1 to n² in a Boustrophedon style starting from the bottom left of the board (i.e. board[n - 1][0]) and alternating direction each row.

You start on square 1 of the board. In each move, starting from square curr, do the following:

Choose a destination square next with a label in the range [curr + 1, min(curr + 6, n²)]. This choice simulates the result of a standard 6-sided die roll.
If next has a snake or ladder, you must move to the destination of that snake or ladder. Otherwise, you move to next.
The game ends when you reach the square n².

A board square on row r and column c has a snake or ladder if board[r][c] != -1. The destination of that snake or ladder is board[r][c].

Squares 1 and n² are not the starting points of any snake or ladder.

Note: You only take a snake or ladder at most once per dice roll. If the destination to a snake or ladder is the start of another snake or ladder, you do not follow the subsequent snake or ladder.

Return the least number of dice rolls required to reach the square n². If it is not possible to reach the square, return -1.

Input & Output

Example 1 — Small Board with Ladder

$ Input: board = [[-1,4],[-1,3]]

› Output: 1

💡 Note: Start at 1. Roll die to reach 2, but there's a ladder at position 2 that takes you directly to position 4 (the target). Total moves: 1.

Example 2 — Larger Board

$ Input: board = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]

› Output: 4

💡 Note: 36 cells total. Need minimum 4 dice rolls to reach cell 36, using optimal path that may include ladders and avoiding snakes.

Example 3 — Impossible Case

$ Input: board = [[-1,-1],[-1,1]]

› Output: -1

💡 Note: There's a snake at position 4 that brings you back to position 1, creating an infinite loop. Impossible to reach the target.

Constraints

n == board.length == board[i].length
2 ≤ n ≤ 20
board[i][j] is either -1 or in the range [1, n²]
The squares labeled 1 and n² do not have any ladders or snakes

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is to use BFS to explore the board level by level, treating each dice roll as an edge in a graph. Since we want the minimum number of dice rolls, BFS guarantees we find the shortest path. Best approach is BFS. Time: O(n²), Space: O(n²)

Common Approaches

✓ Breadth-First Search (Optimal)

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

BFS explores all positions reachable in k moves before exploring positions reachable in k+1 moves. This guarantees we find the shortest path first, making it optimal for unweighted shortest path problems.

Brute Force DFS

⏱️ Time: O(6ⁿ) Space: O(n²)

Recursively explore every possible dice roll (1-6) from each position, tracking the minimum moves needed. This approach tries all combinations but becomes exponentially slow.

Breadth-First Search (Optimal) — Algorithm Steps

Start BFS from position 1
For each position, try all dice rolls 1-6
Handle snakes/ladders by jumping to destination
Track visited positions to avoid cycles
Return moves when reaching target

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start BFS from position 1 with queue and visited set

Level Exploration

Process all positions at current distance simultaneously

Shortest Path

First time we reach target gives minimum moves

Code -

solution.c — C

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

static int board[20][20];
static bool visited[401];

typedef struct {
    int pos;
    int moves;
} State;

void getPosition(int square, int n, int* r, int* c) {
    int row = (square - 1) / n;
    int col = (square - 1) % n;
    if (row % 2 == 1) {
        col = n - 1 - col;
    }
    *r = n - 1 - row;
    *c = col;
}

int solution(int n) {
    int target = n * n;
    State queue[10000];
    int front = 0, rear = 0;
    memset(visited, false, sizeof(visited));
    
    queue[rear++] = (State){1, 0};
    visited[1] = true;
    
    while (front < rear) {
        State curr = queue[front++];
        
        for (int dice = 1; dice <= 6; dice++) {
            int nextPos = curr.pos + dice;
            if (nextPos > target) continue;
            
            int r, c;
            getPosition(nextPos, n, &r, &c);
            if (board[r][c] != -1) {
                nextPos = board[r][c];
            }
            
            if (nextPos == target) {
                return curr.moves + 1;
            }
            
            if (!visited[nextPos]) {
                visited[nextPos] = true;
                queue[rear++] = (State){nextPos, curr.moves + 1};
            }
        }
    }
    
    return -1;
}

int parseBoard() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char* ptr = line + 1; // skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int col = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr == '-') {
                    board[n][col] = -1;
                    ptr += 2; // skip "-1"
                } else {
                    int num = 0;
                    while (*ptr >= '0' && *ptr <= '9') {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    board[n][col] = num;
                }
                col++;
                if (*ptr == ',') ptr++;
            }
            if (*ptr == ']') ptr++;
            n++;
        }
        if (*ptr == ',') ptr++;
    }
    
    return n;
}

int main() {
    int n = parseBoard();
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each cell is visited at most once, and there are n² cells on the board

✓ Linear Growth

Space Complexity

O(n²)

Queue and visited array can store up to n² positions

⚠ Quadratic Space

32.0K 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

Breadth-First Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler