Minimum Moves to Capture The Queen

Minimum Moves to Capture The Queen - Problem

Math Enumeration Medium

There is a 1-indexed 8 x 8 chessboard containing 3 pieces. You are given 6 integers a, b, c, d, e, and f where:

(a, b) denotes the position of the white rook.
(c, d) denotes the position of the white bishop.
(e, f) denotes the position of the black queen.

Given that you can only move the white pieces, return the minimum number of moves required to capture the black queen.

Note that:

Rooks can move any number of squares either vertically or horizontally, but cannot jump over other pieces.
Bishops can move any number of squares diagonally, but cannot jump over other pieces.
A rook or a bishop can capture the queen if it is located in a square that they can move to.
The queen does not move.

Input & Output

Example 1 — Rook Direct Attack

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

› Output: 1

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

Example 2 — Bishop Blocked

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

› Output: 1

💡 Note: Bishop at (1,4) and Queen at (4,1) are on the same diagonal (both differences are 3). Rook at (2,2) is not on this diagonal path, so bishop can capture queen in 1 move.

Example 3 — Bishop Direct Attack

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

› Output: 1

💡 Note: Bishop at (2,2) and Queen at (4,4) are on the same diagonal. Rook at (5,5) doesn't block this diagonal path, so bishop captures in 1 move.

Constraints

1 ≤ a, b, c, d, e, f ≤ 8
No two pieces occupy the same square
All coordinates represent valid chessboard positions

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that we only need to check if either the rook or bishop can capture the queen in 1 move. If neither can attack directly (due to blocking or wrong positioning), the answer is always 2 moves. Best approach uses mathematical conditions to check attack patterns. Time: O(1), Space: O(1)

Common Approaches

✓ Case Analysis

⏱️ Time: O(1) Space: O(1)

Systematically check if the rook or bishop can capture the queen in 1 move (considering blocking), then check if either can capture in 2 moves.

Mathematical Analysis

⏱️ Time: O(1) Space: O(1)

Apply mathematical formulas to determine if pieces can attack: rook needs same row/column, bishop needs same diagonal. Check for blocking using coordinate geometry.

Case Analysis — Algorithm Steps

Check if rook can capture queen in 1 move (same row/column, not blocked)
Check if bishop can capture queen in 1 move (same diagonal, not blocked)
If neither can capture in 1 move, return 2 (always possible)

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Rook

Can rook attack queen directly (same row/column, not blocked)?

Check Bishop

Can bishop attack queen diagonally (not blocked)?

Result

Return 1 if either can attack, otherwise 2

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int solution(int a, int b, int c, int d, int e, int f) {
    // Check if rook can capture queen in 1 move
    int rookCanCapture = 0;
    if (a == e) { // Same row
        // Check if bishop blocks the path
        if (c != a || (d - b) * (d - f) <= 0) {
            rookCanCapture = 1;
        }
    } else if (b == f) { // Same column
        // Check if bishop blocks the path
        if (d != b || (c - a) * (c - e) <= 0) {
            rookCanCapture = 1;
        }
    }
    
    // Check if bishop can capture queen in 1 move
    int bishopCanCapture = 0;
    if (abs_val(c - e) == abs_val(d - f)) { // Same diagonal
        // Check if rook blocks the path
        int rookOnDiagonal = (abs_val(a - c) == abs_val(b - d));
        int rookBlocks = 0;
        if (rookOnDiagonal) {
            // Check if rook is between bishop and queen
            int minX = c < e ? c : e;
            int maxX = c > e ? c : e;
            int minY = d < f ? d : f;
            int maxY = d > f ? d : f;
            if (a > minX && a < maxX && b > minY && b < maxY) {
                rookBlocks = 1;
            }
        }
        if (!rookBlocks) {
            bishopCanCapture = 1;
        }
    }
    
    return (rookCanCapture || bishopCanCapture) ? 1 : 2;
}

int main() {
    int a, b, c, d, e, f;
    scanf("%d", &a);
    scanf("%d", &b);
    scanf("%d", &c);
    scanf("%d", &d);
    scanf("%d", &e);
    scanf("%d", &f);
    
    int result = solution(a, b, c, d, e, f);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Fixed number of position checks regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for coordinate comparisons

✓ Linear Space

18.5K Views

Medium Frequency

~15 min Avg. Time

420 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

Case Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler