Maximum Number of Moves to Kill All Pawns

Maximum Number of Moves to Kill All Pawns - Problem

Array Math Bit Manipulation Breadth-First Search Game Theory Bitmask Hard

Chess Knight Battle: Maximum Moves Strategy

Imagine a strategic chess battle between Alice and Bob on a 50×50 chessboard! There's one knight and several pawns scattered across the board. Alice wants to maximize the total moves, while Bob wants to minimize them.

🎮 Game Rules:

Turn-based gameplay: Alice goes first, then they alternate
Knight movement: Standard chess knight moves (L-shaped: 2 squares in one direction, 1 square perpendicular)
Pawn capture: Each player selects ANY pawn and captures it using the minimum possible moves
Strategic freedom: Players can choose any pawn, not necessarily the closest one

Given the knight's starting position (kx, ky) and an array of pawn positions, determine the maximum total number of moves Alice can achieve when both players play optimally.

Note: The knight can pass through other pawns without capturing them - only the selected pawn gets captured per turn.

Input & Output

example_1.py — Basic Case

$ Input: kx = 1, ky = 1, positions = [[0,0]]

› Output: 4

💡 Note: Knight at (1,1) needs 4 moves to reach pawn at (0,0). Since there's only one pawn, Alice captures it in 4 moves, total = 4.

example_2.py — Two Pawns

$ Input: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,4]]

› Output: 8

💡 Note: Alice will choose the strategy that maximizes total moves. She might capture the farthest pawn first, then Bob will minimize by choosing closer pawns.

example_3.py — Strategic Play

$ Input: kx = 0, ky = 0, positions = [[1,2],[2,4]]

› Output: 6

💡 Note: Alice goes first and can choose either pawn. She'll analyze which choice leads to maximum total moves considering Bob's optimal response.

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

n positions × 2^n possible bitmasks for pawn states, with memoization

✓ Linear Growth

Space Complexity

O(n × 2ⁿ)

Memoization table storing results for each state

⚡ Linearithmic Space

Constraints

0 ≤ kx, ky ≤ 49
1 ≤ positions.length ≤ 15
positions[i].length == 2
0 ≤ positions[i][0], positions[i][1] ≤ 49
All positions are unique
The input is generated such that positions[i] ≠ [kx, ky] for all i

Asked in

This is a game theory problem solved with dynamic programming and bitmasks. The key insight is to precompute all shortest knight paths using BFS, then use minimax with memoization where bitmasks represent captured pawns. Alice maximizes while Bob minimizes the total moves. Time complexity: O(n × 2ⁿ) where n is the number of pawns.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmasks (Optimal)	O(n × 2ⁿ)	O(n × 2ⁿ)	Use memoization with bitmasks to avoid recomputing same game states
Recursive Minimax (Brute Force)	O(n! × 50²)	O(n × 50²)	Try all possible game sequences recursively using minimax algorithm

Dynamic Programming with Bitmasks (Optimal) — Algorithm Steps

Precompute shortest distances between knight start position and all pawns, and between all pairs of pawns using BFS
Use bitmask to represent which pawns have been captured
Use memoization with state (current_position, remaining_pawns_bitmask, is_alice_turn)
Apply minimax with memoization for optimal substructure

Visualization

Tap to expand

Step-by-Step Walkthrough

Precompute Distances

BFS calculates all shortest paths between positions

Bitmask States

Each bit represents whether a pawn has been captured

Memoization

Store results to avoid recomputing same game states

Optimal Result

Return the maximized total moves Alice can achieve

Code -

solution.c — C

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

#define BOARD_SIZE 50
#define MAX_QUEUE 2500
#define MAX_PAWNS 15
#define HASH_SIZE 100000

int directions[8][2] = {{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};

typedef struct {
    int x, y, moves;
} Position;

typedef struct HashNode {
    char key[50];
    int value;
    struct HashNode* next;
} HashNode;

HashNode* hashTable[HASH_SIZE];
int knightToPawn[MAX_PAWNS];
int pawnToPawn[MAX_PAWNS][MAX_PAWNS];
int n;

unsigned int hash(const char* key) {
    unsigned int hash = 5381;
    int c;
    while ((c = *key++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

int getMemo(const char* key) {
    unsigned int index = hash(key);
    HashNode* node = hashTable[index];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return INT_MIN; // Not found
}

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

int bfsShortestPath(int startX, int startY, int endX, int endY) {
    if (startX == endX && startY == endY) return 0;
    
    Position queue[MAX_QUEUE];
    int visited[BOARD_SIZE][BOARD_SIZE];
    memset(visited, 0, sizeof(visited));
    
    int front = 0, rear = 0;
    queue[rear++] = (Position){startX, startY, 0};
    visited[startX][startY] = 1;
    
    while (front < rear) {
        Position curr = queue[front++];
        
        for (int i = 0; i < 8; i++) {
            int nx = curr.x + directions[i][0];
            int ny = curr.y + directions[i][1];
            
            if (nx >= 0 && nx < BOARD_SIZE && ny >= 0 && ny < BOARD_SIZE && !visited[nx][ny]) {
                if (nx == endX && ny == endY) {
                    return curr.moves + 1;
                }
                visited[nx][ny] = 1;
                queue[rear++] = (Position){nx, ny, curr.moves + 1};
            }
        }
    }
    return INT_MAX;
}

int dp(int mask, int lastPos, int isAliceTurn) {
    if (mask == (1 << n) - 1) return 0;
    
    char key[50];
    sprintf(key, "%d,%d,%d", mask, lastPos, isAliceTurn);
    
    int memoResult = getMemo(key);
    if (memoResult != INT_MIN) return memoResult;
    
    int result;
    if (isAliceTurn) {
        result = 0;
        for (int i = 0; i < n; i++) {
            if ((mask & (1 << i)) == 0) {
                int newMask = mask | (1 << i);
                int moves = (lastPos == -1) ? knightToPawn[i] : pawnToPawn[lastPos][i];
                int totalMoves = moves + dp(newMask, i, 0);
                if (totalMoves > result) {
                    result = totalMoves;
                }
            }
        }
    } else {
        result = INT_MAX;
        for (int i = 0; i < n; i++) {
            if ((mask & (1 << i)) == 0) {
                int newMask = mask | (1 << i);
                int moves = (lastPos == -1) ? knightToPawn[i] : pawnToPawn[lastPos][i];
                int totalMoves = moves + dp(newMask, i, 1);
                if (totalMoves < result) {
                    result = totalMoves;
                }
            }
        }
    }
    
    setMemo(key, result);
    return result;
}

int maxMoves(int kx, int ky, int positions[][2], int numPawns) {
    n = numPawns;
    memset(hashTable, 0, sizeof(hashTable));
    
    // Precompute distances
    for (int i = 0; i < n; i++) {
        knightToPawn[i] = bfsShortestPath(kx, ky, positions[i][0], positions[i][1]);
    }
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i != j) {
                pawnToPawn[i][j] = bfsShortestPath(positions[i][0], positions[i][1],
                                                  positions[j][0], positions[j][1]);
            }
        }
    }
    
    return dp(0, -1, 1);
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

n positions × 2^n possible bitmasks for pawn states, with memoization

✓ Linear Growth

Space Complexity

O(n × 2ⁿ)

Memoization table storing results for each state

⚡ Linearithmic Space

Constraints

0 ≤ kx, ky ≤ 49
1 ≤ positions.length ≤ 15
positions[i].length == 2
0 ≤ positions[i][0], positions[i][1] ≤ 49
All positions are unique
The input is generated such that positions[i] ≠ [kx, ky] for all i

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Chess Knight Battle: Maximum Moves Strategy

🎮 Game Rules:

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Bitmasks (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler