Breadth-First Search
Minimum Knight Moves
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] )
public class Solution {
public Integer minimumKnightMoves(Integer x, Integer y) {
// Your code goes here
}
}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
class Solution {public int minimumKnightMoves(int x, int y) {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<int[]> queue = new LinkedList<>();queue.offer(new int[]{0, 0, 0});Set<String> visited = new HashSet<>();visited.add("0,0");// Step 2: Perform BFS traversalwhile (!queue.isEmpty()) {// [cx, cy] is the current knight positionint[] current = queue.poll();int cx = current[0], cy = current[1], moves = current[2];if (cx == x && cy == y) {return moves;}// check all possible moves of the knight from the current positionfor (int[] dir : directions) {int nx = cx + dir[0];int ny = cy + dir[1];String key = nx + "," + ny;// if the new position is not visited yet, add it to the queue// also mark it as visited and increment the number of movesif (!visited.contains(key)) {visited.add(key);queue.offer(new int[]{nx, ny, moves + 1});}}}// if the target position is not reachable, return -1return -1;}}
What is the time complexity of this solution?
O(m * n * 4^L)
O(max(|x|, |y|)²)
O(n!)
O(4^L)