<p>You are given an integer array <code>receiver</code> of length <code>n</code> and an integer <code>k</code>. <code>n</code> players are playing a ball-passing game.</p>

<p>You choose the starting player, <code>i</code>. The game proceeds as follows: player <code>i</code> passes the ball to player <code>receiver[i]</code>, who then passes it to <code>receiver[receiver[i]]</code>, and so on, for <code>k</code> passes in total. The game&#39;s score is the sum of the indices of the players who touched the ball, including repetitions, i.e. <code>i + receiver[i] + receiver[receiver[i]] + ... + receiver<sup>(k)</sup>[i]</code>.</p>

<p>Return&nbsp;the <strong>maximum</strong>&nbsp;possible score.</p>

<p><strong>Notes:</strong></p>

<ul>
	<li><code>receiver</code> may contain duplicates.</li>
	<li><code>receiver[i]</code> may be equal to <code>i</code>.</li>
</ul>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">receiver = [2,0,1], k = 4</span></p>

<p><strong>Output:</strong> <span class="example-io">6</span></p>

<p><strong>Explanation:</strong></p>

<p>Starting with player <code>i = 2</code> the initial score is 2:</p>

<table>
	<tbody>
		<tr>
			<th>Pass</th>
			<th>Sender Index</th>
			<th>Receiver Index</th>
			<th>Score</th>
		</tr>
		<tr>
			<td>1</td>
			<td>2</td>
			<td>1</td>
			<td>3</td>
		</tr>
		<tr>
			<td>2</td>
			<td>1</td>
			<td>0</td>
			<td>3</td>
		</tr>
		<tr>
			<td>3</td>
			<td>0</td>
			<td>2</td>
			<td>5</td>
		</tr>
		<tr>
			<td>4</td>
			<td>2</td>
			<td>1</td>
			<td>6</td>
		</tr>
	</tbody>
</table>
</div>

<p><strong class="example">Example 2:</strong></p>

<div class="example-block">
<p><strong>Input:</strong> <span class="example-io">receiver = [1,1,1,2,3], k = 3</span></p>

<p><strong>Output:</strong> <span class="example-io">10</span></p>

<p><strong>Explanation:</strong></p>

<p>Starting with player <code>i = 4</code> the initial score is 4:</p>

<table>
	<tbody>
		<tr>
			<th>Pass</th>
			<th>Sender Index</th>
			<th>Receiver Index</th>
			<th>Score</th>
		</tr>
		<tr>
			<td>1</td>
			<td>4</td>
			<td>3</td>
			<td>7</td>
		</tr>
		<tr>
			<td>2</td>
			<td>3</td>
			<td>2</td>
			<td>9</td>
		</tr>
		<tr>
			<td>3</td>
			<td>2</td>
			<td>1</td>
			<td>10</td>
		</tr>
	</tbody>
</table>
</div>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= receiver.length == n &lt;= 10<sup>5</sup></code></li>
	<li><code>0 &lt;= receiver[i] &lt;= n - 1</code></li>
	<li><code>1 &lt;= k &lt;= 10<sup>10</sup></code></li>
</ul>

class Solution:
    def getMaxFunctionValue(self, receiver: List[int], k: int) -> int:
        gmx = 0
        n = len(receiver)

        deliver = defaultdict(set)
        for i, p in enumerate(receiver):
            deliver[p].add(i)

        circles = []
        visited_in_circle = set()
        for i in range(n):
            if i not in visited_in_circle:
                ii = None
                visited_in_circle.add(i)
                connected_to_anchor = {i}  
                the_path = [i]
                while True:
                    i = receiver[i]
                    if i in visited_in_circle and i not in connected_to_anchor:
                        break
                    else:
                        visited_in_circle.add(i)
                        if i in connected_to_anchor:
                            ii = the_path.index(i)
                            break
                        connected_to_anchor.add(i)
                        the_path.append(i)
                if ii is not None:
                    circles.append(the_path[ii:])  

        cache = {}
        for circle in circles:
            psm = [0] * (len(circle) + 1)
            for i, node in enumerate(circle):
                psm[i] = psm[i - 1] + node
                deliver[receiver[node]].remove(node)

            for ii, node in enumerate(circle):
                iie = (ii+k) % len(circle)  
                ans = psm[iie] - psm[ii-1]
                d = (k+ii-iie) // len(circle)
                ans += psm[-2] * d
                gmx = max(gmx, ans)
                cache[node] = ans, iie

            visited_in_circle = set(circle)
            for ii, node in enumerate(circle):  
                stack = [node]
                while stack:
                    pas = stack[-1]
                    if deliver[pas]:
                        rec = deliver[pas].pop()
                        if rec not in visited_in_circle:
                            stack.append(rec)
                            ans0, iie0 = cache[pas]
                            if len(stack) <= k + 1:
                                ans = rec + ans0 - circle[iie0]
                                cache[rec] = ans, (iie0 - 1) % len(circle)
                            else:
                                ans = rec + ans0 - stack[-k - 2]
                                cache[rec] = ans, None
                            gmx = max(gmx, ans)
                    else:
                        stack.pop()
        return gmx 
891