Snakes and Ladders - Practice Coding Problems

Snakes and Ladders - Problem

Welcome to the classic Snakes and Ladders board game! 🎲

You're given an n × n board where squares are numbered from 1 to n² in a special zigzag pattern called Boustrophedon. Starting from the bottom-left corner (square 1), numbers alternate direction on each row - like how an ox plows a field back and forth!

Game Rules:

🎯 Goal: Reach square n² with minimum dice rolls
🎲 Movement: Each turn, roll a 6-sided die (move 1-6 squares)
🐍 Snakes: If you land on a snake's head, slide down to its tail
🪜 Ladders: If you land on a ladder's bottom, climb up to its top
⚠️ Important: Only take ONE snake/ladder per dice roll, even if the destination has another!

The board matrix uses -1 for normal squares and positive numbers for snake/ladder destinations. Return the minimum number of dice rolls needed to win, or -1 if impossible.

Input & Output

example_1.py — Basic 6x6 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: Optimal path: 1→2→15→26→27→28→29→30→31→32→33→34→35→36 using moves: 1→2 (roll 1), 2→15 (ladder), 15→26 (roll 6+5=11, but max 6 so multiple rolls), reach 36 in 4 total moves

example_2.py — Small 3x3 Board

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

› Output: 1

💡 Note: Start at 1, roll any number ≥2 to reach squares 3 or 4. Square 3 has ladder to square 3 (no change), square 4 is the target. Only 1 move needed.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: Target is square 9. From square 8, there's a snake back to square 2, making it impossible to reach square 9.

Visualization

Tap to expand

Understanding the Visualization

Setup Board

Convert the 2D matrix to a 1D game board with boustrophedon numbering

BFS Exploration

Use a queue to explore all positions reachable in 1 move, then 2 moves, etc.

Handle Special Squares

When landing on snakes or ladders, immediately move to their destinations

Track Visited

Mark visited squares to avoid infinite loops and redundant work

Find Shortest Path

Return the number of moves when target is first reached

Key Takeaway

🎯 Key Insight: BFS is perfect for finding the shortest path in unweighted graphs. Each dice roll has equal 'cost', making BFS the optimal choice for this minimum moves problem.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each square is visited at most once, and we have n² squares total

⚠ Quadratic Growth

Space Complexity

O(n²)

Queue and visited set can store up to n² positions

⚠ Quadratic Space

Constraints

n == board.length == board[i].length
2 ≤ n ≤ 20
-1 ≤ board[i][j] ≤ n²
Squares 1 and n² do not have snakes or ladders
Only take one snake/ladder per dice roll

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses Breadth-First Search (BFS) to find the shortest path from square 1 to square n². BFS explores positions level by level, guaranteeing that the first time we reach the target is via the minimum number of moves. Key challenges include converting between 1D square numbers and 2D board coordinates using the boustrophedon pattern, and properly handling snakes/ladders.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with Queue (Optimal)	O(n²)	O(n²)	Use breadth-first search to find shortest path in minimum moves
Recursive DFS (Brute Force)	O(6^(n²))	O(n²)	Try every possible sequence of dice rolls recursively

BFS with Queue (Optimal) — Algorithm Steps

Convert 2D board coordinates to 1D square numbers using boustrophedon pattern
Use BFS queue starting from square 1
For each position, try all dice rolls (1-6)
Handle snakes and ladders by jumping to destinations
Use visited set to avoid revisiting positions
Return moves when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0: Start

Begin at square 1 with 0 moves

Level 1: First Roll

Explore squares 2-7 (1 move)

Handle Snakes/Ladders

Jump to destinations if present

Level 2: Second Roll

Explore all reachable squares with 2 moves

Continue Until Target

First time we reach target = shortest path

Code -

solution.c — C

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

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

void getCoordinates(int square, int n, int* row, int* col) {
    square--;
    *row = n - 1 - square / n;
    *col = (n - 1 - *row) % 2 == 0 ? square % n : n - 1 - (square % n);
}

int snakesAndLadders(int** board, int boardSize, int* boardColSize) {
    int n = boardSize;
    int target = n * n;
    
    State* queue = malloc(target * sizeof(State));
    bool* visited = calloc(target + 1, sizeof(bool));
    int front = 0, rear = 0;
    
    queue[rear++] = (State){1, 0};
    visited[1] = true;
    
    while (front < rear) {
        State curr = queue[front++];
        
        if (curr.pos == target) {
            free(queue);
            free(visited);
            return curr.moves;
        }
        
        for (int dice = 1; dice <= 6; dice++) {
            int nextSquare = curr.pos + dice;
            if (nextSquare > target) break;
            
            int row, col;
            getCoordinates(nextSquare, n, &row, &col);
            if (board[row][col] != -1) {
                nextSquare = board[row][col];
            }
            
            if (!visited[nextSquare]) {
                visited[nextSquare] = true;
                queue[rear++] = (State){nextSquare, curr.moves + 1};
            }
        }
    }
    
    free(queue);
    free(visited);
    return -1;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each square is visited at most once, and we have n² squares total

⚠ Quadratic Growth

Space Complexity

O(n²)

Queue and visited set can store up to n² positions

⚠ Quadratic Space

Constraints

n == board.length == board[i].length
2 ≤ n ≤ 20
-1 ≤ board[i][j] ≤ n²
Squares 1 and n² do not have snakes or ladders
Only take one snake/ladder per dice roll

68.3K Views

Medium Frequency

~25 min Avg. Time

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

BFS with Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler