<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 Solution:
    def maxMoves(self, kx: int, ky: int, positions: List[List[int]]) -> int:
        # global vars
        dirs = [(2, 1), (2, -1), (-2, 1), (-2, -1), (1, 2), (1, -2), (-1, 2), (-1, -2)]
        psize = len(positions)
        ptopos = {}  # index from a pawn position to index in another array
        for i in range(psize):
            x, y = positions[i]
            ptopos[(x, y)] = i

        def isvalid(x, y, seen):
            if x < 0 or y < 0 or x >= 50 or y >= 50:
                return False
            if (x, y) in seen:
                return False
            return True

        # bfs vars
        step = 1
        seen = set()
        seen.add((kx, ky))
        curr = [(kx, ky)]
        pseensofar = (
            0  # add counter to keep track of remain pawn. If all seen, can break early
        )
        arrtod = [-1] * psize  # knight to distance to each pawn

        # bfs from start position to all pawns
        while len(curr):
            nxt = []
            for x, y in curr:
                for dx, dy in dirs:
                    nx, ny = x + dx, y + dy
                    if isvalid(nx, ny, seen):
                        ctemp = (nx, ny)
                        if ctemp in ptopos:
                            arrtod[ptopos[ctemp]] = step
                            pseensofar += 1
                            if pseensofar == psize:
                                break
                        seen.add(ctemp)
                        nxt.append(ctemp)
                if pseensofar == psize:  # return early is all pawns visited
                    nxt = []
                    break
            step += 1
            curr = nxt
        # print(arrtod)

        ptoparr = []  # distance for each pawn to all other pawns (based on index)
        for i in range(psize):
            toadd = [-1] * psize
            toadd[i] = 0
            ptoparr.append(toadd)

        # bfs from all pawns to all other pawns
        for i in range(psize):
            currCoord = (positions[i][0], positions[i][1])

            step = 1
            seen = set()
            seen.add(currCoord)
            curr = [currCoord]
            pseensofar = 1

            while len(curr):
                nxt = []
                for x, y in curr:
                    for dx, dy in dirs:
                        nx, ny = x + dx, y + dy
                        if isvalid(nx, ny, seen):
                            ctemp = (nx, ny)
                            if ctemp in ptopos:
                                ptoparr[i][ptopos[ctemp]] = step
                                pseensofar += 1
                                if pseensofar == psize:
                                    break
                            seen.add(ctemp)
                            nxt.append(ctemp)
                    if pseensofar == psize:  # return early is all pawns visited
                        nxt = []
                        break
                step += 1
                curr = nxt

        # precomputation done; dfs looking for highest (alice) or lowest (bob) using bitmask
        res = 0

        def getAvail(darr, remain):
            lo, hi = float("inf"), float("-inf")
            arr = []
            for i in range(psize):
                curr = 1 << i
                if (curr & remain) > 0:
                    distance = darr[i]
                    arr.append([i, distance])
                    lo = min(lo, distance)
                    hi = max(hi, distance)
            return arr
            isBob = (psize - len(arr)) % 2
            res = []
            toMatch = lo if isBob else hi
            for ind, d in arr:
                if d == toMatch:
                    res.append(ind)
            return (res, toMatch)

        @lru_cache(maxsize=None)
        def helper(px, py, remain):
            if remain == 0:
                return 0
            darr = None
            if px == kx and py == ky:
                darr = arrtod
            else:
                darr = ptoparr[ptopos[(px, py)]]

            avail = getAvail(darr, remain)  # available indices to expand
            isBob = (psize - len(avail)) % 2
            # try every index
            res = None
            for ind, d in avail:
                nx, ny = positions[ind]
                temp = d + helper(nx, ny, remain ^ (1 << ind))
                if res == None:
                    res = temp
                elif isBob:
                    res = min(res, temp)
                else:
                    res = max(res, temp)
            return res

        hi = 0
        ref = (1 << psize) - 1
        for i in range(psize):
            nx, ny = positions[i]
            hi = max(hi, arrtod[i] + helper(nx, ny, ref ^ (1 << i)))
        return hi

72228