Program to find out the minimum moves in a snakes and ladders game in Python

The Snakes and Ladders game requires finding the minimum number of dice rolls to reach position 100 from position 1. In this problem, we can roll any number from 1 to 6 on the dice, and the board contains ladders (which help us climb up) and snakes (which make us slide down).

We'll use a Breadth-First Search (BFS) approach to find the shortest path, as BFS guarantees finding the minimum number of moves in an unweighted graph.

Problem Understanding

Given the positions of ladders and snakes:

• Ladders: [(start, end)] where end > start (move forward)
• Snakes: [(start, end)] where end < start (move backward)
• Goal: Reach position 100 with minimum dice rolls

Algorithm Steps

The solution follows these steps ?

• Combine ladders and snakes into a single edges dictionary
• Use BFS to explore all possible positions level by level
• Track visited positions to avoid cycles
• For each position, try all dice rolls (1-6)
• Apply snake/ladder transformations when landing on special squares
• Return the number of moves when reaching position 100

Implementation

def solve(ladders, snakes):
    # Combine ladders and snakes into edges dictionary
    ladders.extend(snakes)
    edges = {}
    for start, end in ladders:
        edges[start] = end
    
    # BFS setup
    visited = set()
    current_positions = set()
    current_positions.add(1)  # Start from position 1
    moves = 0
    
    # BFS to find minimum moves
    while 100 not in current_positions:
        moves += 1
        next_positions = set()
        
        for position in current_positions:
            # Try all possible dice rolls (1-6)
            for dice_roll in range(1, 7):
                new_position = position + dice_roll
                
                # Don't go beyond position 100
                if new_position > 100:
                    continue
                
                # Apply snake or ladder if present
                if new_position in edges:
                    new_position = edges[new_position]
                
                # Skip if already visited
                if new_position in visited:
                    continue
                
                visited.add(new_position)
                next_positions.add(new_position)
        
        current_positions = next_positions
    
    return moves

# Test with the given example
ladders = [(11, 40), (37, 67), (47, 73), (15, 72)]
snakes = [(90, 12), (98, 31), (85, 23), (75, 42), (70, 18), (49, 47)]

result = solve(ladders, snakes)
print(f"Minimum moves required: {result}")

Minimum moves required: 8

How It Works

The algorithm works as follows ?

Key Features

• BFS Approach: Guarantees finding the minimum number of moves
• Edge Mapping: Combines snakes and ladders in a single dictionary
• Visited Tracking: Prevents infinite loops and redundant calculations
• Level-by-Level: Explores all positions reachable in the same number of moves

Time Complexity

The time complexity is O(N) where N is the number of squares on the board (100). Each position is visited at most once, and for each position, we check 6 possible dice rolls.

Conclusion

This BFS solution efficiently finds the minimum moves in a Snakes and Ladders game by exploring all positions level by level. The algorithm handles both ladders and snakes uniformly through an edges dictionary, ensuring optimal pathfinding.