<p>There is a <code>50 x 50</code> chessboard with <strong>one</strong> knight and some pawns on it. You are given two integers <code>kx</code> and <code>ky</code> where <code>(kx, ky)</code> denotes the position of the knight, and a 2D array <code>positions</code> where <code>positions[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> denotes the position of the pawns on the chessboard.</p>

<p>Alice and Bob play a <em>turn-based</em> game, where Alice goes first. In each player&#39;s turn:</p>

<ul>
	<li>The player <em>selects </em>a pawn that still exists on the board and captures it with the knight in the <strong>fewest</strong> possible <strong>moves</strong>. <strong>Note</strong> that the player can select <strong>any</strong> pawn, it <strong>might not</strong> be one that can be captured in the <strong>least</strong> number of moves.</li>
	<li><span>In the process of capturing the <em>selected</em> pawn, the knight <strong>may</strong> pass other pawns <strong>without</strong> capturing them</span>. <strong>Only</strong> the <em>selected</em> pawn can be captured in <em>this</em> turn.</li>
</ul>

<p>Alice is trying to <strong>maximize</strong> the <strong>sum</strong> of the number of moves made by <em>both</em> players until there are no more pawns on the board, whereas Bob tries to <strong>minimize</strong> them.</p>

<p>Return the <strong>maximum</strong> <em>total</em> number of moves made during the game that Alice can achieve, assuming both players play <strong>optimally</strong>.</p>

<p>Note that in one <strong>move, </strong>a chess knight has eight possible positions it can move to, as illustrated below. Each move is two cells in a cardinal direction, then one cell in an orthogonal direction.</p>

<p><img src="https://assets.leetcode.com/uploads/2024/08/01/chess_knight.jpg" style="width: 275px; height: 273px;" /></p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">kx = 1, ky = 1, positions = [[0,0]]</span></p>

<p><strong>Output:</strong> <span class="example-io">4</span></p>

<p><strong>Explanation:</strong></p>

<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/16/gif3.gif" style="width: 275px; height: 275px;" /></p>

<p>The knight takes 4 moves to reach the pawn at <code>(0, 0)</code>.</p>
</div>

<p><strong class="example">Example 2:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]</span></p>

<p><strong>Output:</strong> <span class="example-io">8</span></p>

<p><strong>Explanation:</strong></p>

<p><strong><img alt="" src="https://assets.leetcode.com/uploads/2024/08/16/gif4.gif" style="width: 320px; height: 320px;" /></strong></p>

<ul>
	<li>Alice picks the pawn at <code>(2, 2)</code> and captures it in two moves: <code>(0, 2) -&gt; (1, 4) -&gt; (2, 2)</code>.</li>
	<li>Bob picks the pawn at <code>(3, 3)</code> and captures it in two moves: <code>(2, 2) -&gt; (4, 1) -&gt; (3, 3)</code>.</li>
	<li>Alice picks the pawn at <code>(1, 1)</code> and captures it in four moves: <code>(3, 3) -&gt; (4, 1) -&gt; (2, 2) -&gt; (0, 3) -&gt; (1, 1)</code>.</li>
</ul>
</div>

<p><strong class="example">Example 3:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">kx = 0, ky = 0, positions = [[1,2],[2,4]]</span></p>

<p><strong>Output:</strong> <span class="example-io">3</span></p>

<p><strong>Explanation:</strong></p>

<ul>
	<li>Alice picks the pawn at <code>(2, 4)</code> and captures it in two moves: <code>(0, 0) -&gt; (1, 2) -&gt; (2, 4)</code>. Note that the pawn at <code>(1, 2)</code> is not captured.</li>
	<li>Bob picks the pawn at <code>(1, 2)</code> and captures it in one move: <code>(2, 4) -&gt; (1, 2)</code>.</li>
</ul>
</div>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>0 &lt;= kx, ky &lt;= 49</code></li>
	<li><code>1 &lt;= positions.length &lt;= 15</code></li>
	<li><code>positions[i].length == 2</code></li>
	<li><code>0 &lt;= positions[i][0], positions[i][1] &lt;= 49</code></li>
	<li>All <code>positions[i]</code> are unique.</li>
	<li>The input is generated such that <code>positions[i] != [kx, ky]</code> for all <code>0 &lt;= i &lt; positions.length</code>.</li>
</ul>

from collections import deque
from typing import List

class Solution:
    def __init__(self):
        self.dx = [1,2,2,1,-1,-2,-2,-1]
        self.dy = [2,1,-1,-2,-2,-1,1,2]
        self.possible_moves_count = 8
        self.M = None
        self.N = None
        self.shortest_path_dict = {}
        self.dp = {}
        self.positions = []
        self.coord_bits = 10  # Number of bits to represent coordinates (e.g., 10 bits for each coordinate)

    def check_if_coord_in_board(self, coords):
        x, y = coords
        return 0 <= x < self.M and 0 <= y < self.N

    def calculate_number_of_moves_for_knight_using_bfs(self, a, b):
        coords_q = deque([(a, 0)])
        visited_coords = set()
        while coords_q:
            coord, moves = coords_q.popleft()
            x2, y2 = coord
            if coord not in visited_coords:
                if coord == b:
                    return moves
                visited_coords.add(coord)
                for i in range(self.possible_moves_count):
                    new_coords = (x2 + self.dx[i], y2 + self.dy[i])
                    is_coord_valid = self.check_if_coord_in_board(new_coords)
                    if is_coord_valid and new_coords not in visited_coords:
                        coords_q.append((new_coords, moves + 1))
        return -1  # Just in case no path is found (shouldn't happen on a valid chessboard)

    def calculate_min_moves(self, knight_coord, positions):
        for i in range(len(positions)):
            ith_coord = (positions[i][0], positions[i][1])
            self.positions.append(ith_coord)

            # Calculate moves for knight to ith pawn
            moves = self.calculate_number_of_moves_for_knight_using_bfs(knight_coord, ith_coord)
            self.shortest_path_dict[(knight_coord, ith_coord)] = moves

            # Calculate moves between all pawns
            for j in range(i + 1, len(positions)):
                jth_coord = (positions[j][0], positions[j][1])
                moves = self.calculate_number_of_moves_for_knight_using_bfs(ith_coord, jth_coord)
                self.shortest_path_dict[(ith_coord, jth_coord)] = moves
                self.shortest_path_dict[(jth_coord, ith_coord)] = moves

    def encode_state(self, mask, knight_pos):
        # Encode knight's position into the state bitmask
        knight_x, knight_y = knight_pos
        knight_bits = (knight_x << self.coord_bits) | knight_y
        return (mask << (2 * self.coord_bits)) | knight_bits

    def decode_state(self, state):
        mask = state >> (2 * self.coord_bits)
        knight_bits = state & ((1 << (2 * self.coord_bits)) - 1)
        knight_x = knight_bits >> self.coord_bits
        knight_y = knight_bits & ((1 << self.coord_bits) - 1)
        return mask, (knight_x, knight_y)

    def calculate_max_moves_in_game(self, state):
        if state in self.dp:
            return self.dp[state]

        mask, knight_pos = self.decode_state(state)
        if mask == (1 << len(self.positions)) - 1:  # If all pawns are collected
            return 0

        count = bin(mask).count('1')
        candidate_pawns = [i for i in range(len(self.positions)) if not (mask & (1 << i))]

        if count % 2 == 1:  # Bob's turn (minimize moves)
            min_moves = float('inf')
            for index in candidate_pawns:
                new_mask = mask | (1 << index)
                new_pos = self.positions[index]
                encoded_state = self.encode_state(new_mask, new_pos)
                min_moves = min(min_moves, self.shortest_path_dict[(knight_pos, new_pos)] + self.calculate_max_moves_in_game(encoded_state))
            self.dp[state] = min_moves
        else:  # Alice's turn (maximize moves)
            max_moves = 0
            for index in candidate_pawns:
                new_mask = mask | (1 << index)
                new_pos = self.positions[index]
                encoded_state = self.encode_state(new_mask, new_pos)
                max_moves = max(max_moves, self.shortest_path_dict[(knight_pos, new_pos)] + self.calculate_max_moves_in_game(encoded_state))
            self.dp[state] = max_moves

        return self.dp[state]

    def maxMoves(self, kx: int, ky: int, positions: List[List[int]]) -> int:
        self.M = 50
        self.N = 50
        self.total_pos = len(positions)
        self.calculate_min_moves((kx, ky), positions)
        
        # Initialize the starting mask and the knight's position
        start_mask = 0  # No pawns collected yet
        start_coords = (kx, ky)
        
        # Encode the starting state
        start_state = self.encode_state(start_mask, start_coords)
        
        # Calculate the maximum moves
        return self.calculate_max_moves_in_game(start_state)
43559