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

class DpElem:
    def __init__(self, position: int, player: int, visited: int) -> None:
        self.position = position
        self.player = player
        self.visited = visited

    def __hash__(self) -> int:
        return hash((self.position, self.player, self.visited))

    def __eq__(self, other: "DpElem") -> bool:
        return (self.position == other.position and self.player == other.player
                and self.visited == other.visited)


class Solution:
    def __init__(self):
        self.dp = {}

    def maxMoves(self, kx: int, ky: int, positions: List[List[int]]) -> int:
        n = 50
        positions.append([kx, ky])
        adj_list = {}

        for i in range(len(positions)):
            adj_list[i] = []
            bfs_queue = deque()
            visited = [[False for _ in range(50)] for _ in range(50)]

            bfs_queue.append([positions[i], 0])
            visited[positions[i][0]][positions[i][1]] = True
            while len(bfs_queue) > 0:
                node = bfs_queue.popleft()
                x = node[0][0]
                y = node[0][1]
                cost = node[1]

                for j in range(len(positions)):
                    if positions[j][0] == x and positions[j][1] == y:
                        adj_list[i].append([j, cost])
                        break

                if x-2 >= 0 and y-1 >= 0 and visited[x-2][y-1] is False:
                    bfs_queue.append([[x-2, y-1], cost+1])
                    visited[x-2][y-1] = True
                if x-1 >= 0 and y-2 >= 0 and visited[x-1][y-2] is False:
                    bfs_queue.append([[x-1, y-2], cost+1])
                    visited[x-1][y-2] = True
                if x+2 < n and y+1 < n and visited[x+2][y+1] is False:
                    bfs_queue.append([[x+2, y+1], cost+1])
                    visited[x+2][y+1] = True
                if x+1 < n and y+2 < n and visited[x+1][y+2] is False:
                    bfs_queue.append([[x+1, y+2], cost+1])
                    visited[x+1][y+2] = True
                if x+2 < n and y-1 >= 0 and visited[x+2][y-1] is False:
                    bfs_queue.append([[x+2, y-1], cost+1])
                    visited[x+2][y-1] = True
                if x+1 < n and y-2 >= 0 and visited[x+1][y-2] is False:
                    bfs_queue.append([[x+1, y-2], cost+1])
                    visited[x+1][y-2] = True
                if x-2 >= 0 and y+1 < n and visited[x-2][y+1] is False:
                    bfs_queue.append([[x-2, y+1], cost+1])
                    visited[x-2][y+1] = True
                if x-1 >= 0 and y+2 < n and visited[x-1][y+2] is False:
                    bfs_queue.append([[x-1, y+2], cost+1])
                    visited[x-1][y+2] = True
        visited = 0
        visited |= (1 << (len(positions) - 1))
        return self.__recur(len(positions) - 1, adj_list, 0, visited)

    def __recur(self, position: int, adj_list: Dict[int, List[List[int]]], player: int, visited: int) -> int:
        if player == 0:
            opt = -sys.maxsize - 1
            neighbors = adj_list[position]
            for i in range(len(neighbors)):
                neighbor = neighbors[i]
                neighbor_pos = neighbor[0]
                neighbor_cost = neighbor[1]

                if (visited & (1 << neighbor_pos)) == 0:
                    visited |= (1 << neighbor_pos)
                    if DpElem(neighbor_pos, 1, visited) in self.dp:
                        opt = max(opt, neighbor_cost + self.dp[DpElem(neighbor_pos, 1, visited)])
                    else:
                        opt = max(opt, neighbor_cost + self.__recur(neighbor_pos, adj_list, 1, visited))
                    visited &= ~(1 << neighbor_pos)

            if opt == -sys.maxsize - 1:
                self.dp[DpElem(position, player, visited)] = 0
                return 0
            self.dp[DpElem(position, player, visited)] = opt
            return opt
        else:
            opt = sys.maxsize
            neighbors = adj_list[position]
            for i in range(len(neighbors)):
                neighbor = neighbors[i]
                neighbor_pos = neighbor[0]
                neighbor_cost = neighbor[1]

                if (visited & (1 << neighbor_pos)) == 0:
                    visited |= (1 << neighbor_pos)
                    if DpElem(neighbor_pos, 0, visited) in self.dp:
                        opt = min(opt, neighbor_cost + self.dp[DpElem(neighbor_pos, 0, visited)])
                    else:
                        opt = min(opt, neighbor_cost + self.__recur(neighbor_pos, adj_list, 0, visited))
                    visited &= ~(1 << neighbor_pos)
            if opt == sys.maxsize:
                self.dp[DpElem(position, player, visited)] = 0
                return 0
            self.dp[DpElem(position, player, visited)] = opt
            return opt
14708