Breadth-First Search

Minimum Knight Moves

medium

DESCRIPTION (inspired by Leetcode.com)

You are given a chessboard of infinite size where the coordinates of each cell are defined by integer pairs (x, y). The knight piece moves in an L-shape, either two squares horizontally and one square vertically, or two squares vertically and one square horizontally.

Write a function to determine the minimum number of moves required for the knight to move from the starting position (0, 0) to the target position (x, y). Assume that it is always possible to reach the target position, and that x and y are both integers in the range [-200, 200]

Example 1:

Input:

x = 1
y = 2

Output: 1

Explanation: The knight can move from (0, 0) to (1, 2) in one move.

Example 2:

x = 4
y = 4

Output: 4

Explanation: The knight can move from (0, 0) to (4, 4) in four moves ( [0, 0] -> [2, 1] -> [4, 2] -> [6, 3] -> [4, 4] )

Code Editor

Run your code to see results here

Have suggestions or found something wrong?

Explanation

We can model this problem as a graph where each cell on the chessboard is a node, and the neighbors of a cell are the cells that can be reached by a knight's move from that cell. Since this is a shortest path problem, we can use a breadth-first search (BFS) traversal to find the minimum number of moves required to reach the target cell (x, y) starting from the cell (0, 0).

Step 1: Initialize the Queue and Visited Set

We start by initializing our BFS queue with the starting cell (0, 0) along with the number of moves required to reach that cell, which is 0 to start. We also initialize a set to keep track of the cells we have visited, so that we don't revisit them (to avoid infinite loops).

Step 2: Perform BFS Traversal

We then perform a BFS traversal by repeatedly dequeuing from the front of the queue. Each time we dequeue, we get both the current knight position, and the number of moves required to reach that position. We then check if the current knight position is the target cell (x, y). If it is, we return the number of moves required to reach that cell.

Otherwise, for each valid knight move from the current position that has not been visited before, we add that position to the queue, along with the number of moves required to reach that position (which is 1 + the current # of moves). We also mark the current cell as visited.

Solution

from collections import deque
class Solution:
    def minimum_knight_moves(self, x: int, y: int) -> int:
        directions = [(2, 1), (2, -1), (-2, 1), (-2, -1),
                      (1, 2), (1, -2), (-1, 2), (-1, -2)]
        
        # Step 1: Initialize the queue and visited set
        queue = deque([(0, 0, 0)])
        visited = set((0, 0))
        # Step 2: Perform BFS traversal 
        while queue:
            # (cx, cy) is the current knight position
            cx, cy, moves = queue.popleft()
            
            if (cx, cy) == (x, y):
                return moves
            
            # check all possible moves of the knight from the current position
            for dx, dy in directions:
                nx, ny = cx + dx, cy + dy
               
                # if the new position is not visited yet, add it to the queue
                # also mark it as visited and increment the number of moves
                if (nx, ny) not in visited:
                    visited.add((nx, ny))
                    queue.append((nx, ny, moves + 1))
        
        # if the target position is not reachable, return -1
        return -1

What is the time complexity of this solution?

O(m * n * 4^L)

O(max(|x|, |y|)²)

O(n!)

O(4^L)

Mark as read

Next: Rotting Oranges