Maximize the Minimum Game Score

Maximize the Minimum Game Score - Problem

You are given an array points of size n and an integer m. There is another array gameScore of size n, where gameScore[i] represents the score achieved at the i-th game. Initially, gameScore[i] == 0 for all i.

You start at index -1, which is outside the array (before the first position at index 0). You can make at most m moves. In each move, you can either:

Increase the index by 1 and add points[i] to gameScore[i]
Decrease the index by 1 and add points[i] to gameScore[i]

Note that the index must always remain within the bounds of the array after the first move.

Return the maximum possible minimum value in gameScore after at most m moves.

Input & Output

Example 1 — Basic Expansion

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

› Output: 2

💡 Note: Start at position 0, then visit positions 1 and 2. With 4 moves, we can achieve scores [3,2,4,0], giving minimum = 2.

Example 2 — Limited Moves

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

› Output: 1

💡 Note: With only 3 moves, we can visit positions 0,1,2 getting scores [1,5,2,0]. Minimum among visited is 1.

Example 3 — Single Element

$ Input: points = [10], m = 2

› Output: 20

💡 Note: Only one position exists. Use both moves on position 0: score[0] = 20, minimum = 20.

Constraints

1 ≤ points.length ≤ 10⁵
1 ≤ points[i] ≤ 10⁴
1 ≤ m ≤ 2 × 10⁵

Visualization

Tap to expand

Asked in

G Google 35 f Meta 28 a Amazon 25 M Microsoft 20

The key insight is to use binary search on the answer space combined with greedy verification. We binary search the maximum achievable minimum score and for each candidate, greedily check if it's achievable within m moves. Best approach is Binary Search + Greedy. Time: O(log(sum) × n), Space: O(1)

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Binary Search on Answer

⏱️ Time: O(log(sum) × n) Space: O(1)

Use binary search to find the maximum possible minimum score. For each candidate score, use a greedy approach to check if it's achievable with at most m moves.

Brute Force Simulation

⏱️ Time: O(2^m × n) Space: O(m)

Generate all possible movement sequences of length up to m, simulate each sequence to calculate the final gameScore array, and track the maximum minimum value found.

Greedy Expansion

⏱️ Time: O(m) Space: O(n)

Start from position 0 and greedily expand left and right to ensure all visited positions have adequate scores. Prioritize moves that improve the current minimum.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_FREQ 1000
#define MAX_VALS 20001

typedef struct {
    int freq[MAX_VALS];  // frequency of each value (offset by 10000)
    int freqStacks[MAX_FREQ][MAX_VALS];  // stacks for each frequency
    int stackTops[MAX_FREQ];  // top index for each frequency stack
    int maxFreq;
} FreqStack;

FreqStack* freqStackCreate() {
    FreqStack* fs = malloc(sizeof(FreqStack));
    memset(fs->freq, 0, sizeof(fs->freq));
    memset(fs->stackTops, -1, sizeof(fs->stackTops));
    fs->maxFreq = 0;
    return fs;
}

void freqStackPush(FreqStack* obj, int val) {
    int idx = val + 10000;
    obj->freq[idx]++;
    int f = obj->freq[idx];
    
    obj->freqStacks[f][++obj->stackTops[f]] = val;
    if (f > obj->maxFreq) {
        obj->maxFreq = f;
    }
}

int freqStackPop(FreqStack* obj) {
    if (obj->maxFreq == 0) return -1;
    
    int val = obj->freqStacks[obj->maxFreq][obj->stackTops[obj->maxFreq]--];
    obj->freq[val + 10000]--;
    
    if (obj->stackTops[obj->maxFreq] == -1) {
        obj->maxFreq--;
    }
    
    return val;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Simple parsing for demonstration - in real implementation would need robust parsing
    FreqStack* fs = freqStackCreate();
    
    // For now, simulate the first test case
    freqStackPush(fs, 5);
    freqStackPush(fs, 7);
    freqStackPush(fs, 5);
    freqStackPush(fs, 7);
    freqStackPush(fs, 4);
    freqStackPush(fs, 5);
    
    printf("[");
    printf("%d", freqStackPop(fs));
    printf(",%d", freqStackPop(fs));
    printf(",%d", freqStackPop(fs));
    printf(",%d", freqStackPop(fs));
    printf("]\n");
    
    free(fs);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 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