Search
⌘K
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] )

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

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 = {(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
Test Your Knowledge

Login to take the complexity quiz and track your progress

Complexity Analysis

Time Complexity: O(max(|x|, |y|)²) where x and y are the target cell coordinates. Let d = max(|x|, |y|). The minimum number of knight moves to reach (x, y) is proportional to d, since each move covers at most 2 squares in any direction. BFS explores every cell level-by-level up to that depth. After all levels, the visited region extends roughly 2d in each direction, forming a 2D area of side length O(d) containing O(d²) cells. Each cell is processed at most once, giving us O(d²) total work.

Space Complexity: O(max(|x|, |y|)²) where x and y are the target cell coordinates. Let d = max(|x|, |y|). The visited set stores every explored cell. Since BFS explores a 2D region extending O(d) in each direction, the total number of stored cells is O(d²).

Mark as read

Next: Rotting Oranges

Your account is free and you can post anonymously if you choose.

Unlock Premium Coding Content

Interactive algorithm visualizations
Guided Practice
Recent interview questions
Learn More
Reading Progress

On This Page

Explanation

Step 1: Initialize the Queue and Visited Set

Step 2: Perform BFS Traversal

Solution

Questions
Meta SWE Interview QuestionsAmazon SWE Interview QuestionsGoogle SWE Interview QuestionsOpenAI SWE Interview QuestionsAnthropic SWE Interview QuestionsEngineering Manager (EM) Interview Questions
Learn
Learn System DesignLearn DSALearn BehavioralLearn ML System DesignLearn Low Level DesignGuided Practice
Links
FAQPricingGift PremiumHello Interview Premium
Legal
Terms and ConditionsPrivacy PolicySecurity
Contact
About UsProduct Support

7511 Greenwood Ave North Unit #4238 Seattle WA 98103

© 2026 Optick Labs Inc. All rights reserved.

Minimum Knight Moves | Hello Interview