Maximize the Minimum Game Score - Practice Coding Problems

Maximize the Minimum Game Score - Problem

Maximize the Minimum Game Score

Imagine you're a game player standing outside an arcade with n games arranged in a line. You start at position -1 (before the first game) and have m moves to maximize your minimum score across all games.

🎮 The Setup:
• You have an array points[i] representing the points you can earn at game i
• Each game starts with gameScore[i] = 0
• You can move left or right, but must stay within bounds after your first move
• Each time you visit a game, you add points[i] to gameScore[i]

🎯 The Goal: Make m moves to maximize the minimum value in your gameScore array. This means you want to ensure even your worst-performing game has as high a score as possible!

Example: If points = [2, 3, 1, 4] and m = 4, you might visit games strategically to ensure no game is left with a score of 0.

Input & Output

example_1.py — Basic Case

$ Input: points = [2, 3, 1, 4], m = 4

› Output: 2

💡 Note: Start at -1. Move right to game 0 (1 move), play it once (+2 points). Move right to game 2 (2 moves total), play it twice (+2 points total, 4 moves used). Final scores: [2, 0, 2, 0]. Minimum = 0. Better strategy: visit each game once for scores [2, 3, 1, 4], minimum = 1. Even better: visit game 2 twice and games 0,1 once each for minimum score of 2.

example_2.py — High Value Game

$ Input: points = [1, 1, 1, 10], m = 6

› Output: 1

💡 Note: With 6 moves, we can visit the first 3 games (1+2+3=6 moves from start) to get scores [1, 1, 1, 0]. The minimum score is 1. We can't efficiently reach game 3 and also boost other games enough to get a minimum > 1.

example_3.py — Limited Moves

$ Input: points = [5, 2], m = 1

› Output: 0

💡 Note: With only 1 move, we can either visit game 0 (scores: [5, 0]) or game 1 (scores: [0, 2]). In both cases, the minimum score is 0, as we can't visit both games.

Constraints

1 ≤ n ≤ 10⁴
1 ≤ points[i] ≤ 10⁶
1 ≤ m ≤ 10⁵
You start at position -1 (outside the array)
After the first move, you must stay within bounds [0, n-1]

Visualization

Tap to expand

Understanding the Visualization

Binary Search Setup

Set up search range for possible minimum scores

Greedy Verification

For each candidate minimum score, use greedy strategy to check achievability

Optimal Movement

Always prioritize visiting games with lowest current scores

Result Convergence

Binary search converges to the maximum achievable minimum score

Key Takeaway

🎯 Key Insight: The monotonic property (if score X is achievable, then all scores < X are achievable) makes this perfect for binary search on the answer, combined with greedy verification for optimal efficiency.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses binary search on the answer combined with a greedy verification strategy. We search for the maximum achievable minimum score by testing each candidate with a greedy algorithm that efficiently allocates moves to ensure all games meet the target minimum score. This approach leverages the monotonic property: if we can achieve minimum score X, we can achieve any score less than X.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer + Greedy	O(n × log(max_score) × m)	O(n)	Binary search on the minimum score, using greedy strategy to check feasibility
Brute Force (Try All Paths)	O(2^m)	O(m × n)	Recursively try all possible movement sequences and track the maximum achievable minimum score

Binary Search on Answer + Greedy — Algorithm Steps

Set search range: left = 0, right = maximum possible score
For each mid value in binary search, check if it's achievable
Greedy check: try to achieve minimum score 'mid' for all games
Start from position -1 and greedily move to maintain feasibility
If achievable with ≤ m moves, search for higher minimum scores
If not achievable, search for lower minimum scores

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Range Setup

Set left=0, right=estimated maximum possible minimum score

Binary Search

For each midpoint, check if that minimum score is achievable

Greedy Verification

Use greedy strategy to see if we can achieve target minimum with m moves

Search Space Reduction

If achievable, search higher; if not, search lower

Code -

solution.c — C

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

int min_array(int* arr, int size) {
    int minVal = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < minVal) {
            minVal = arr[i];
        }
    }
    return minVal;
}

int sum_array(int* arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int canAchieveMinScore(int* points, int n, int m, int targetMin) {
    int* gameScores = calloc(n, sizeof(int));
    int pos = -1;
    int movesUsed = 0;
    
    while (movesUsed < m) {
        int minScore = min_array(gameScores, n);
        if (minScore >= targetMin) {
            free(gameScores);
            return 1;
        }
        
        // Find closest game with minimum score
        int bestGame = -1;
        int bestDistance = INT_MAX;
        
        for (int i = 0; i < n; i++) {
            if (gameScores[i] == minScore) {
                int distance = pos >= 0 ? abs_val(i - pos) : i + 1;
                if (distance < bestDistance) {
                    bestDistance = distance;
                    bestGame = i;
                }
            }
        }
        
        if (movesUsed + bestDistance > m) {
            free(gameScores);
            return 0;
        }
        
        pos = bestGame;
        movesUsed += bestDistance;
        
        // Visit this game as much as needed
        while (movesUsed < m && gameScores[pos] < targetMin) {
            gameScores[pos] += points[pos];
            movesUsed++;
            
            if (movesUsed < m) {
                int leftBenefit = 0;
                int rightBenefit = 0;
                
                if (pos > 0 && gameScores[pos-1] < targetMin) {
                    leftBenefit = points[pos-1];
                }
                if (pos < n-1 && gameScores[pos+1] < targetMin) {
                    rightBenefit = points[pos+1];
                }
                
                if (leftBenefit > points[pos] && gameScores[pos] >= targetMin) {
                    pos--;
                    gameScores[pos] += points[pos];
                    movesUsed++;
                } else if (rightBenefit > points[pos] && gameScores[pos] >= targetMin) {
                    pos++;
                    gameScores[pos] += points[pos];
                    movesUsed++;
                }
            }
        }
    }
    
    int result = min_array(gameScores, n) >= targetMin;
    free(gameScores);
    return result;
}

int maxMinGameScore(int* points, int n, int m) {
    int left = 0;
    int right = sum_array(points, n) * m / n;
    int result = 0;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canAchieveMinScore(points, n, m, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int points[] = {2, 3, 1, 4};
    int n = 4, m = 4;
    printf("%d\n", maxMinGameScore(points, n, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max_score) × m)

Binary search has log(max_score) iterations, each verification takes O(n×m) in worst case

⚡ Linearithmic

Space Complexity

O(n)

Only need to track game scores and temporary arrays

⚡ Linearithmic Space

21.1K Views

Medium-High Frequency

~35 min Avg. Time

892 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

Binary Search on Answer + Greedy — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler