<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

class Solution:
    def maxMoves(self, kx: int, ky: int, positions: List[List[int]]) -> int:
        move = [(1,2), (2, 1), (-1, 2), (-2, 1), (-1, -2), (-2, -1), (1,-2), (2, -1)]


        @cache
        def bfs(start_x, start_y, end_x, end_y):
            lst = deque([(start_x, start_y, 0)])
            visited = set()
            visited.add((start_x, start_y))
            while lst:
                x, y, dist = lst.popleft()
                if x == end_x and y == end_y:
                    return dist
                for m in move:
                    new_x = x + m[0]
                    new_y = y + m[1]
                    if 0 <= new_x < 50 and 0 <= new_y < 50 and (new_x, new_y) not in visited:
                        visited.add((new_x, new_y))
                        lst.append((new_x, new_y, dist + 1))
        
        final = (1 << len(positions)) - 1
        @cache
        def minmax(x, y, picks, alice):
            if picks == final:
                return 0
            
            moves = float("-inf") if alice else float("inf")
            for ind, position in enumerate(positions):
                if picks & (1 << ind) == 0:
                    dist = bfs(x, y, *position)
                    if alice:
                        moves = max(moves, dist + minmax(*position, picks ^ (1 << ind), not alice))
                    else:
                        moves = min(moves, dist + minmax(*position, picks ^ (1 << ind), not alice))

            return moves


        return minmax(kx, ky, 0, True)


        # # Define knight's possible movements
        # knight_moves = [(2, 1), (1, 2), (-1, 2), (-2, 1), (-2, -1), (-1, -2), (1, -2), (2, -1)]

        # @cache
        # def bfs(kx, ky, px, py):
        #     # Perform BFS to find the shortest distance from (kx, ky) to (px, py)
        #     queue = deque([(kx, ky, 0)])  # (x, y, distance)
        #     visited = set([(kx, ky)])
            
        #     while queue:
        #         x, y, dist = queue.popleft()
        #         if (x, y) == (px, py):
        #             return dist
                
        #         for dx, dy in knight_moves:
        #             nx, ny = x + dx, y + dy
        #             if 0 <= nx < 50 and 0 <= ny < 50 and (nx, ny) not in visited:
        #                 visited.add((nx, ny))
        #                 queue.append((nx, ny, dist + 1))
            
        #     return float('inf')  # Should not reach here in a valid scenario

        # total = (1 << len(positions)) - 1
        # @cache
        # def minimax(kx, ky, p, is_alice_turn):
        #     # If no pawns are left, return 0 moves
        #     if p == total:
        #         return 0
            
            
        #     best_moves = float('-inf') if is_alice_turn else float('inf')
            
        #     # Try capturing each pawn and calculate the result
        #     for i, (px, py) in enumerate(positions):
        #         if p & (1 << i) == 0:
        #             dist = bfs(kx, ky, px, py)  # Distance to capture this pawn
        #             # Recursively call minimax for the next turn
        #             next_moves = dist + minimax(px, py, p | (1 << i), not is_alice_turn)
                    
        #             if is_alice_turn:
        #                 best_moves = max(best_moves, next_moves)  # Alice maximizes
        #             else:
        #                 best_moves = min(best_moves, next_moves)  # Bob minimizes
            
        #     return best_moves
            
        # return minimax(kx, ky, 0, True)



139990