Minimum Knight Moves - Practice Coding Problems

Minimum Knight Moves - Problem

Breadth-First Search Medium

Minimum Knight Moves

Imagine you're playing chess on an infinite chessboard that extends in all directions from -infinity to +infinity. Your knight starts at position [0, 0] and needs to reach a target square at coordinates [x, y].

A knight moves in an L-shape: exactly two squares in one cardinal direction (north, south, east, or west), then one square perpendicular to that direction. This gives the knight 8 possible moves from any position.

Goal: Find the minimum number of moves required for the knight to travel from [0, 0] to [x, y].

The key insight is that this is a shortest path problem on an infinite grid, where each position is a node and knight moves are the edges.

Input & Output

example_1.py — Basic Case

$ Input: x = 2, y = 1

› Output: 1

💡 Note: The knight can reach [2,1] in exactly 1 move from [0,0]. This is one of the 8 possible knight moves: 2 squares right, 1 square up.

example_2.py — Multiple Steps

$ Input: x = 5, y = 5

› Output: 4

💡 Note: One optimal path: [0,0] → [2,1] → [4,2] → [3,4] → [5,5]. The knight needs exactly 4 moves to reach [5,5].

example_3.py — Origin Case

$ Input: x = 0, y = 0

› Output: 0

💡 Note: The knight is already at the target position [0,0], so no moves are needed.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Knight starts at origin [0,0] with 0 moves taken

Level 1 Exploration

Explore all 8 positions reachable in exactly 1 knight move

Level 2 Exploration

From each Level 1 position, explore all reachable positions in 1 more move

Continue Until Target

Keep expanding level by level until target is found

Shortest Path Found

The first time we reach target guarantees minimum moves

Key Takeaway

🎯 Key Insight: BFS explores positions in order of distance from start, guaranteeing the first path found to any position is the shortest possible.

Time & Space Complexity

Time Complexity

⏱️

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

BFS explores positions in a roughly circular pattern around the origin, with radius proportional to the distance to target

✓ Linear Growth

Space Complexity

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

Space needed for queue and visited set, which store all explored positions

✓ Linear Space

Constraints

|x| + |y| ≤ 300
-300 ≤ x, y ≤ 300
The answer is guaranteed to exist

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal solution uses Breadth-First Search (BFS) to explore positions level by level. BFS guarantees that the first time we reach the target position, it's via the shortest path. Key optimizations include using symmetry to work in the first quadrant and pruning the search space to avoid exploring positions too far from the target.

Common Approaches

Approach	Time	Space	Notes
✓ BFS with Hash Set (Optimal)	O(max(\|x\|, \|y\|)²)	O(max(\|x\|, \|y\|)²)	Use BFS to explore positions level by level, guaranteeing shortest path
Brute Force DFS (All Paths)	O(8^n)	O(n)	Explore all possible paths using DFS until target is reached

BFS with Hash Set (Optimal) — Algorithm Steps

Initialize BFS queue with starting position [0,0] and step count 0
Use hash set to track visited positions
For each position in current level, try all 8 knight moves
Add unvisited valid positions to queue for next level
Return step count when target is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start at [0,0] - 0 moves

Level 1

Explore all positions reachable in 1 move

Level 2

Explore all positions reachable in 2 moves

Found Target

First time we reach target gives minimum moves

Code -

solution.c — C

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

#define MAX_QUEUE_SIZE 100000
#define HASH_SIZE 10007

typedef struct {
    int x, y, steps;
} QueueNode;

typedef struct HashNode {
    char key[32];
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
QueueNode queue[MAX_QUEUE_SIZE];
int front = 0, rear = 0;

int hash(const char* key) {
    int hash = 0;
    while (*key) {
        hash = (hash * 31 + *key) % HASH_SIZE;
        key++;
    }
    return hash;
}

int contains(const char* key) {
    int index = hash(key);
    HashNode* node = hashTable[index];
    while (node) {
        if (strcmp(node->key, key) == 0) return 1;
        node = node->next;
    }
    return 0;
}

void insert(const char* key) {
    int index = hash(key);
    HashNode* newNode = (HashNode*)malloc(sizeof(HashNode));
    strcpy(newNode->key, key);
    newNode->next = hashTable[index];
    hashTable[index] = newNode;
}

int minKnightMoves(int x, int y) {
    x = abs(x);
    y = abs(y);
    
    if (x == 0 && y == 0) return 0;
    
    int moves[8][2] = {{2,1}, {2,-1}, {-2,1}, {-2,-1}, {1,2}, {1,-2}, {-1,2}, {-1,-2}};
    
    memset(hashTable, 0, sizeof(hashTable));
    front = rear = 0;
    
    queue[rear++] = (QueueNode){0, 0, 0};
    insert("0,0");
    
    while (front < rear) {
        QueueNode curr = queue[front++];
        
        for (int i = 0; i < 8; i++) {
            int newX = curr.x + moves[i][0];
            int newY = curr.y + moves[i][1];
            
            if (newX == x && newY == y) {
                return curr.steps + 1;
            }
            
            char key[32];
            sprintf(key, "%d,%d", newX, newY);
            
            if (!contains(key) && newX >= -1 && newY >= -1 && newX <= x + 2 && newY <= y + 2) {
                insert(key);
                queue[rear++] = (QueueNode){newX, newY, curr.steps + 1};
            }
        }
    }
    
    return -1;
}

int main() {
    int x, y;
    scanf("%d %d", &x, &y);
    printf("%d\n", minKnightMoves(x, y));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

BFS explores positions in a roughly circular pattern around the origin, with radius proportional to the distance to target

✓ Linear Growth

Space Complexity

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

Space needed for queue and visited set, which store all explored positions

✓ Linear Space

Constraints

|x| + |y| ≤ 300
-300 ≤ x, y ≤ 300
The answer is guaranteed to exist

52.0K Views

Medium Frequency

~25 min Avg. Time

1.9K 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 Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler