## Minimum Knight Moves

###### DESCRIPTION (credit 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]

###### EXAMPLES

**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] )

Run your code to see results here

## 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 dequeclass 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 setqueue = deque([(0, 0, 0)])visited = set((0, 0))# Step 2: Perform BFS traversalwhile queue:# (cx, cy) is the current knight positioncx, cy, moves = queue.popleft()if (cx, cy) == (x, y):return moves# check all possible moves of the knight from the current positionfor 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 movesif (nx, ny) not in visited:visited.add((nx, ny))queue.append((nx, ny, moves + 1))# if the target position is not reachable, return -1return -1

## Complexity Analysis

**Time Complexity:** O(x * y), where x and y are the absolute values of the target cell coordinates. The time complexity is dominated by the BFS traversal, which visits all cells in the worst case, and there are a total of x * y cells on the chessboard.

**Space Complexity:** O(x * y), where x and y are the absolute values of the target cell coordinates. The space complexity is dominated by the visited set, which can contain all cells in the worst case, and there are a total of x * y cells on the chessboard.

Loading comments...