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

dirs = [(i, j) for i in [-2, -1, 1, 2] for j in [-2, -1, 1, 2] if abs(i) + abs(j) == 3]
inf = 10 ** 6
fmin = lambda x, y: x if x < y else y
fmax = lambda x, y: x if x > y else y

class Solution:
    def Knight_dist(self, start, end):
        x = abs(start[0] - end[0])
        y = abs(start[1] - end[1])
        x1 = max(x, y)
        x2 = min(x, y)
        if (x1, x2) == (1, 1) and (start in [(0, 0), (49, 0), (0, 49), (49, 49)] or 
                                    end in [(0, 0), (49, 0), (0, 49), (49, 49)]):
            return 4
        if (x1, x2) == (1, 0): return 3
        if (x1, x2) == (2, 2): return 4
        d = max((x1+1)//2, (x1+x2+2)//3) + ((x1+x2) - max((x1+1)//2, (x1+x2+2)//3)) % 2
        return d
    def maxMoves(self, kx: int, ky: int, positions: List[List[int]]) -> int:
        ps = positions + [[kx, ky]]
        k = len(ps)
        saved = [[0] * k for _ in range(k)]
        for i in range(k):
            x, y = ps[i]
            dis = [[101] * 50 for _ in range(50)]
            dis[x][y] = 0
            dq = deque([(x, y)])
            while dq:
                u, v = dq.popleft()
                for du, dv in dirs:
                    if 0 <= u + du < 50 and 0 <= v + dv < 50 and dis[u+du][v+dv] == 101:
                        dis[u+du][v+dv] = dis[u][v] + 1
                        dq.append((u + du, v + dv))
            for j in range(k):
                saved[i][j] = dis[ps[j][0]][ps[j][1]]
        
        n = len(positions)  # Number of pawns (max 15)

        # DP table, initialized with infinity for minimization, and zero for maximization
        dp = [[float('-inf')] * n for _ in range(1 << n)]  # -inf since Alice tries to maximize

        # Initialize base cases: capturing a single pawn (last pawn captured)
        for i in range(n):
            dp[1 << i][i] = 0  # Knight starting from (kx, ky) to pawn i

        # Iterate over all masks with increasing number of bits set
        for mask in range(1 << n):
            pawn_count = bin(mask).count('1') 
            ids = [j for j in range(n) if mask >> j & 1]

            for starting_pawn in ids:
                old_mask = mask ^ (1 << starting_pawn)
                for next_pawn in ids:
                    if next_pawn == starting_pawn:
                        continue
                    # Turn alternation logic: if pawn_count is even, it's Alice's turn (maximize)
                    if (n - pawn_count) % 2 == 0:
                        if dp[mask][starting_pawn] == float('-inf'):
                            dp[mask][starting_pawn] = float('inf')
                        dp[mask][starting_pawn] = fmin(
                            dp[mask][starting_pawn], 
                            dp[old_mask][next_pawn] + saved[starting_pawn][next_pawn]
                        )
                    else:  # If pawn_count is odd, it's Bob's turn (minimize)

                        dp[mask][starting_pawn] = fmax(
                            dp[mask][starting_pawn],
                            dp[old_mask][next_pawn] + saved[starting_pawn][next_pawn]
                        )
                print(f"{bin(mask)[2:].zfill(3)} {starting_pawn} {dp[mask][starting_pawn]}")


        # The result is when all pawns are captured, find the maximum for Alice
        final_mask = (1 << n) - 1  # Mask representing all pawns captured
        result = 0
        for i in range(n):
            result = max(result, dp[final_mask][i] + saved[-1][i])
        print(saved)
        return result
22709