<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:
        neighbors = {}
        for x in range(50):
            for y in range(50):
                for (i, j) in [(x + 2, y + 1), (x + 2, y - 1), (x - 2, y + 1), (x - 2, y - 1), (x - 1, y + 2), (x - 1, y - 2), (x + 1, y - 2), (x + 1, y + 2)]:
                    if i >= 0 and i < 50 and j >= 0 and j < 50:
                        a = (x, y)
                        b = (i, j)
                        if a not in neighbors:
                            neighbors[a] = [b]
                        else:
                            neighbors[a].append(b)
                        if b not in neighbors:
                            neighbors[b] = [a]
                        else:
                            neighbors[b].append(a)
        # Dijkstra 
        coordinates = list(map(lambda x: (x[0], x[1]), positions))
        all_coordinates = coordinates.copy()
        all_coordinates.append((kx, ky))
        sd = {}
        for coordinate in all_coordinates:
            sd[coordinate] = self.dijkstra(coordinate, all_coordinates, neighbors)
        maxie_answers = {}
        minni_answers = {}
        pawn_status = "1" * len(coordinates) + "0"
        return self.maxie(maxie_answers, minni_answers, all_coordinates, len(all_coordinates) - 1, pawn_status, sd)
        
        
    def dijkstra(self, coordinate, all_coordinates, neighbors):
        dist = {}
        frontier = set()
        frontier.add(coordinate)
        d = 1 
        seen = set()
        seen.add(coordinate)
        while frontier:
            new_frontier = set()
            for x in frontier:
                for new_node in neighbors[x]:
                    if new_node not in seen:
                        seen.add(new_node)
                        new_frontier.add(new_node)
                        if new_node in all_coordinates:
                            dist[new_node] = d 
                            if len(dist) == len(all_coordinates) - 1:
                                return dist 
            d += 1 
            frontier = new_frontier
        return dist
    
    
    def maxie(self, maxie_answers, minni_answers, all_coordinates, knight_pos, pawn_status, sd):
        pawns = self.find_ones(pawn_status)
        knight_coor = all_coordinates[knight_pos]
        if len(pawns) == 1:
            pawn_coor = all_coordinates[pawns[0]]
            result = sd[knight_coor][pawn_coor]
            maxie_answers[(knight_pos, pawn_status)] = result
            return result 
        else:
            if (knight_pos, pawn_status) in maxie_answers:
                return maxie_answers[(knight_pos, pawn_status)]
            result = 0
            for p in pawns:
                pawn_coor = all_coordinates[p]
                new_pawn_status = [x for x in pawn_status]
                new_pawn_status[p] = '0'
                new_pawn_status = ''.join(new_pawn_status)
                new_knight_pos = p 
                curr_res = sd[knight_coor][pawn_coor] + self.minni(maxie_answers, minni_answers, all_coordinates, new_knight_pos, new_pawn_status, sd)
                if curr_res > result:
                    result = curr_res 
            maxie_answers[(knight_pos, pawn_status)] = result
            return result
                
    
    def minni(self, maxie_answers, minni_answers, all_coordinates, knight_pos, pawn_status, sd):
        pawns = self.find_ones(pawn_status)
        knight_coor = all_coordinates[knight_pos]
        if len(pawns) == 1:
            pawn_coor = all_coordinates[pawns[0]]
            result = sd[knight_coor][pawn_coor]
            minni_answers[(knight_pos, pawn_status)] = result
            return result 
        else:
            if (knight_pos, pawn_status) in minni_answers:
                return minni_answers[(knight_pos, pawn_status)]
            result = 1000000000
            for p in pawns:
                pawn_coor = all_coordinates[p]
                new_pawn_status = [x for x in pawn_status]
                new_pawn_status[p] = '0'
                new_pawn_status = ''.join(new_pawn_status)
                new_knight_pos = p 
                curr_res = sd[knight_coor][pawn_coor] + self.maxie(maxie_answers, minni_answers, all_coordinates, new_knight_pos, new_pawn_status, sd)
                if curr_res < result:
                    result = curr_res 
            minni_answers[(knight_pos, pawn_status)] = result
            return result
    
    
    def find_ones(self, s):
        result = []
        for i in range(len(s)):
            if s[i] == "1":
                result.append(i)
        return result
        
67015