<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 typing import List, Tuple
from collections import deque
from functools import lru_cache

class Solution:
    def maxMoves(self, kx: int, ky: int, positions: List[List[int]]) -> int:
        """
        Given a 50x50 chessboard with one knight and several pawns,
        determine the maximum total number of moves made during the game
        when Alice and Bob play optimally.

        :param kx: int - Knight's starting x-coordinate
        :param ky: int - Knight's starting y-coordinate
        :param positions: List[List[int]] - Positions of pawns
        :return: int - Maximum total number of moves
        """
        n = len(positions)
        if n == 0:
            return 0  # No pawns to capture

        # Assign indices to pawns
        pawn_indices = {tuple(pos): idx for idx, pos in enumerate(positions)}
        
        # Precompute minimum knight moves between any two positions using BFS
        # Since the board is 50x50, BFS is feasible
        def bfs(start: Tuple[int, int]) -> List[List[int]]:
            moves = [[-1 for _ in range(50)] for _ in range(50)]
            queue = deque()
            x, y = start
            moves[x][y] = 0
            queue.append((x, y))
            directions = [(-2, -1), (-1, -2), (1, -2), (2, -1),
                          (2, 1), (1, 2), (-1, 2), (-2, 1)]
            while queue:
                cx, cy = queue.popleft()
                for dx, dy in directions:
                    nx, ny = cx + dx, cy + dy
                    if 0 <= nx < 50 and 0 <= ny < 50 and moves[nx][ny] == -1:
                        moves[nx][ny] = moves[cx][cy] + 1
                        queue.append((nx, ny))
            return moves
        
        # Compute distances from the starting position to all pawns
        start_moves = bfs((kx, ky))
        distances = [[0 for _ in range(n)] for _ in range(n)]
        for i in range(n):
            xi, yi = positions[i]
            # Compute distances from pawn i to all other pawns
            pawn_moves = bfs((xi, yi))
            for j in range(n):
                if i != j:
                    xj, yj = positions[j]
                    distances[i][j] = pawn_moves[xj][yj]
                else:
                    distances[i][j] = 0  # Same position

        # Compute distances from starting position to all pawns
        start_to_pawn = [start_moves[pos[0]][pos[1]] for pos in positions]
        
        # Edge case: If any pawn is unreachable, return 0
        for dist in start_to_pawn:
            if dist == -1:
                return 0
        
        # Now, define the DP function with memoization
        @lru_cache(maxsize=None)
        def dp(mask: int, pos: int) -> int:
            """
            Compute the maximum total number of moves from the current state.

            :param mask: int - Bitmask representing captured pawns
            :param pos: int - Current position of the knight (0 to n-1), or -1 for starting position
            :return: int - Maximum total moves from this state
            """
            if mask == (1 << n) - 1:
                return 0  # All pawns captured

            # Determine whose turn it is
            captured = bin(mask).count('1')
            is_alice_turn = (captured % 2 == 0)  # Alice starts first

            if is_alice_turn:
                max_total = -float('inf')
                for i in range(n):
                    if not (mask & (1 << i)):
                        # Compute distance from current position to pawn i
                        if pos == -1:
                            dist = start_to_pawn[i]
                        else:
                            dist = distances[pos][i]
                        if dist == -1:
                            continue  # Unreachable pawn
                        # Capture pawn i
                        total = dist + dp(mask | (1 << i), i)
                        if total > max_total:
                            max_total = total
                return max_total if max_total != -float('inf') else 0
            else:
                min_total = float('inf')
                for i in range(n):
                    if not (mask & (1 << i)):
                        # Compute distance from current position to pawn i
                        if pos == -1:
                            dist = start_to_pawn[i]
                        else:
                            dist = distances[pos][i]
                        if dist == -1:
                            continue  # Unreachable pawn
                        # Capture pawn i
                        total = dist + dp(mask | (1 << i), i)
                        if total < min_total:
                            min_total = total
                return min_total if min_total != float('inf') else 0

        # Initial call: no pawns captured, knight at starting position (-1)
        return dp(0, -1)
85259