Minimum Moves to Capture The Queen - Practice Coding Problems

Minimum Moves to Capture The Queen - Problem

Math Enumeration Medium

Chess Strategy Challenge: You're controlling the white pieces on a standard 8×8 chessboard to capture the black queen in the minimum number of moves possible.

The board contains exactly 3 pieces:
• A white rook at position (a, b)
• A white bishop at position (c, d)
• A black queen at position (e, f)

Movement Rules:
• Rooks move any number of squares horizontally or vertically
• Bishops move any number of squares diagonally
• Neither piece can jump over other pieces
• The queen remains stationary

Goal: Return the minimum number of moves needed to capture the queen using optimal strategy.

Input & Output

example_1.py — Direct Rook Attack

$ Input: a = 1, b = 1, c = 8, d = 8, e = 2, f = 3

› Output: 2

💡 Note: Rook at (1,1) cannot directly attack queen at (2,3) since they don't share row/column. Bishop at (8,8) also cannot directly attack. Any piece can reach the queen in 2 moves maximum.

example_2.py — Blocked Rook Path

$ Input: a = 5, b = 3, c = 3, d = 4, e = 5, f = 2

› Output: 1

💡 Note: Rook at (5,3) and queen at (5,2) are on the same row. Bishop at (3,4) doesn't block this horizontal path, so rook can capture in 1 move.

example_3.py — Direct Bishop Attack

$ Input: a = 4, b = 3, c = 3, d = 4, e = 5, f = 2

› Output: 1

💡 Note: Bishop at (3,4) and queen at (5,2) are on the same diagonal (difference of coordinates both equal 2). Rook at (4,3) doesn't block this diagonal path, so bishop can capture in 1 move.

Constraints

1 ≤ a, b, c, d, e, f ≤ 8
No two pieces occupy the same position
All positions are valid chessboard coordinates
The chessboard is standard 8×8 size

Visualization

Tap to expand

Understanding the Visualization

Identify Attack Lines

Rook attacks horizontally/vertically, bishop attacks diagonally

Check Path Obstruction

Verify if the other piece blocks the direct attack path

Apply 2-Move Guarantee

If no direct attack, any piece can reach target in 2 moves

Key Takeaway

🎯 Key Insight: The answer is always 1 or 2 moves. Either a piece can directly attack the queen (1 move), or it needs to reposition first (2 moves maximum for any chess piece to reach any square).

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses geometric analysis to recognize that the answer is always 1 or 2 moves. Check if the rook can attack the queen directly (same row/column with clear path), then check if the bishop can attack directly (same diagonal with clear path). If neither piece can capture in 1 move, the answer is 2 moves since any chess piece can reach any position in at most 2 moves.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Positions)	O(64²)	O(64)	Try all possible moves for both pieces and find minimum path length
Mathematical Analysis (Optimal)	O(1)	O(1)	Analyze geometric relationships between pieces in two phases
Single Pass Geometric Analysis (Optimal)	O(1)	O(1)	Analyze both pieces simultaneously using chess movement geometry

Brute Force (Check All Positions) — Algorithm Steps

Generate all valid rook moves (horizontal/vertical lines)
Generate all valid bishop moves (diagonal lines)
For each possible move, check if it captures the queen
If not, generate next level moves until queen is captured
Return minimum moves found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Rook Moves

Check all horizontal and vertical positions the rook can reach

Generate Bishop Moves

Check all diagonal positions the bishop can reach

Test Each Path

For each possible move, check if it leads to queen capture

Code -

solution.c — C

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

int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
int abs_val(int x) { return x < 0 ? -x : x; }

bool canRookCapture(int rx, int ry, int qx, int qy, int bx, int by) {
    if (rx != qx && ry != qy) return false;
    if (rx == qx && qx == bx && min(ry, qy) < by && by < max(ry, qy)) return false;
    if (ry == qy && qy == by && min(rx, qx) < bx && bx < max(rx, qx)) return false;
    return true;
}

bool canBishopCapture(int bx, int by, int qx, int qy, int rx, int ry) {
    if (abs_val(bx - qx) != abs_val(by - qy)) return false;
    int dx = qx > bx ? 1 : -1;
    int dy = qy > by ? 1 : -1;
    int x = bx + dx, y = by + dy;
    while (x != qx) {
        if (x == rx && y == ry) return false;
        x += dx;
        y += dy;
    }
    return true;
}

int minimumMovesToCaptureTheQueen(int a, int b, int c, int d, int e, int f) {
    if (canRookCapture(a, b, e, f, c, d)) return 1;
    if (canBishopCapture(c, d, e, f, a, b)) return 1;
    return 2;
}

Time & Space Complexity

Time Complexity

⏱️

O(64²)

In worst case, we check all 64 positions for each piece, leading to quadratic time

✓ Linear Growth

Space Complexity

O(64)

Need to store visited positions and possible moves

✓ Linear Space

42.0K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler