Minimum Levels to Gain More Points

Minimum Levels to Gain More Points - Problem

You are given a binary array possible of length n. Alice and Bob are playing a game that consists of n levels. Some of the levels in the game are impossible to clear while others can always be cleared.

In particular, if possible[i] == 0, then the i-th level is impossible to clear for both the players. A player gains 1 point on clearing a level and loses 1 point if the player fails to clear it.

At the start of the game, Alice will play some levels in the given order starting from the 0-th level, after which Bob will play for the rest of the levels. Alice wants to know the minimum number of levels she should play to gain more points than Bob, if both players play optimally to maximize their points.

Return the minimum number of levels Alice should play to gain more points. If this is not possible, return -1. Note that each player must play at least 1 level.

Input & Output

Example 1 — Basic Case

$ Input: possible = [1,0,1,0]

› Output: 1

💡 Note: Alice plays level 0 (gains 1 point), Bob plays levels 1,2,3 (loses 1, gains 1, loses 1 = -1 total). Alice: 1, Bob: -1, so Alice wins with just 1 level.

Example 2 — Need More Levels

$ Input: possible = [1,1,1,0]

› Output: 2

💡 Note: If Alice plays 1 level: Alice=1, Bob=1+1+(-1)=1 (tie). If Alice plays 2 levels: Alice=1+1=2, Bob=1+(-1)=0, Alice wins with 2 levels.

Example 3 — Impossible

$ Input: possible = [0,0]

› Output: -1

💡 Note: Both levels are impossible. Both players will lose points, so Alice cannot gain more points than Bob.

Constraints

2 ≤ possible.length ≤ 10⁵
possible[i] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32

The key insight is to use prefix sums to efficiently calculate Alice's score vs Bob's remaining score for each possible split point. Best approach uses prefix sum optimization with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

For each possible number of levels Alice can play (1 to n-1), calculate Alice's score and Bob's score, then check if Alice wins.

Prefix Sum Optimization

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

Calculate prefix sums once, then use them to quickly determine Alice's and Bob's scores for any split point.

Brute Force — Algorithm Steps

Try each split point from 1 to n-1
Calculate Alice's score for first k levels
Calculate Bob's score for remaining levels
Return minimum k where Alice's score > Bob's score

Visualization

Tap to expand

Step-by-Step Walkthrough

Split at k=1

Alice gets first level, Bob gets rest

Split at k=2

Alice gets first 2 levels, Bob gets rest

Find Winner

Return first k where Alice > Bob

Code -

solution.c — C

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

int solution(int* possible, int n) {
    for (int k = 1; k < n; k++) {
        // Alice plays first k levels
        int aliceScore = 0;
        for (int i = 0; i < k; i++) {
            aliceScore += possible[i] == 1 ? 1 : -1;
        }
        
        // Bob plays remaining levels
        int bobScore = 0;
        for (int i = k; i < n; i++) {
            bobScore += possible[i] == 1 ? 1 : -1;
        }
        
        if (aliceScore > bobScore) {
            return k;
        }
    }
    
    return -1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int possible[1000];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '[' && token[0] != ']') {
            possible[n++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int result = solution(possible, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n split points, we calculate scores in O(n) time

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for calculations

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~18 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler