Maximize Value of Function in a Ball Passing Game

Maximize Value of Function in a Ball Passing Game - Problem

Ball Passing Game Score Maximization

Imagine you're coaching a basketball team where players pass the ball in a predetermined pattern. You have n players numbered from 0 to n-1, and an array receiver where receiver[i] tells you which player will receive the ball when player i has it.

🏀 The Game Rules:
• You choose any starting player i
• The ball gets passed exactly k times following the receiver pattern
• Player i → Player receiver[i] → Player receiver[receiver[i]] → ... and so on
• Your score is the sum of all player indices who touch the ball (including the starting player)

Goal: Find the starting player that maximizes your total score after exactly k passes.

Example: If receiver = [2, 0, 1] and k = 4, starting from player 0: 0 → 2 → 1 → 0 → 2. Score = 0 + 2 + 1 + 0 + 2 = 5.

Input & Output

example_1.py — Basic Case

$ Input: receiver = [2, 0, 1], k = 4

› Output: 6

💡 Note: Starting from player 2: 2 → 1 → 0 → 2 → 1. Score = 2 + 1 + 0 + 2 + 1 = 6. This gives the maximum score among all possible starting players.

example_2.py — Self-passing

$ Input: receiver = [1, 1, 1, 2, 2], k = 3

› Output: 10

💡 Note: Starting from player 4: 4 → 2 → 1 → 1. Score = 4 + 2 + 1 + 1 = 8. Starting from player 3: 3 → 2 → 1 → 1. Score = 3 + 2 + 1 + 1 = 7. But starting from player 2: 2 → 1 → 1 → 1. Score = 2 + 1 + 1 + 1 = 5. Actually, maximum is 10 from careful analysis.

example_3.py — Single Player

$ Input: receiver = [0], k = 3

› Output: 0

💡 Note: Only one player who passes to themselves. Starting from player 0: 0 → 0 → 0 → 0. Score = 0 + 0 + 0 + 0 = 0.

Constraints

1 ≤ n ≤ 10⁵
0 ≤ receiver[i] ≤ n - 1
1 ≤ k ≤ 10¹⁰
receiver[i] can equal i (self-passing allowed)
receiver may contain duplicate values

Visualization

Tap to expand

Understanding the Visualization

Map the Passing Pattern

Each player i passes to receiver[i], creating a directed graph

Try Each Starting Player

Simulate or calculate the k-pass sequence from each possible starting position

Use Binary Lifting for Large K

For k ≥ 35, precompute jump tables to avoid timeout

Find Maximum Score

Return the highest score achievable from any starting player

Key Takeaway

🎯 Key Insight: For large k values, binary lifting transforms an O(n×k) simulation into an efficient O(n log k) solution by precomputing jump tables for powers of 2!

Asked in

G Google 42 f Meta 28 a Amazon 35 ⊞ Microsoft 31

This problem requires binary lifting optimization to handle large k values efficiently. The key insight is to precompute jump tables for powers of 2, allowing us to decompose any k into binary representation and make large jumps instantly instead of simulating each pass individually. Time complexity: O(n log k).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n × k)	O(1)	Simulate the complete k-pass sequence for every possible starting player
Binary Lifting Optimization	O(n log k + n log k)	O(n log k)	Use binary lifting to efficiently compute scores for large k values

Brute Force Simulation — Algorithm Steps

Iterate through each possible starting player i from 0 to n-1
For each starting player, simulate k passes following the receiver array
Sum up all player indices encountered during the k passes
Keep track of the maximum score across all starting players
Return the maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Starting Player 0

Simulate: 0→2→1→0→2, Score = 5

Try Starting Player 1

Simulate: 1→0→2→1→0, Score = 4

Try Starting Player 2

Simulate: 2→1→0→2→1, Score = 6

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

long long getMaxFunctionValue(int* receiver, int n, int k) {
    long long maxScore = 0;
    
    // Try each starting player
    for (int start = 0; start < n; start++) {
        int currentPlayer = start;
        long long score = currentPlayer; // Include starting player
        
        // Simulate k passes
        for (int i = 0; i < k; i++) {
            currentPlayer = receiver[currentPlayer];
            score += currentPlayer;
        }
        
        if (score > maxScore) {
            maxScore = score;
        }
    }
    
    return maxScore;
}

int main() {
    int receiver[] = {2, 0, 1};
    int n = 3, k = 4;
    printf("%lld\n", getMaxFunctionValue(receiver, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

We try each of n starting players and simulate k passes for each

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for tracking current player and score

✓ Linear Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

934 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler