Stone Game VIII

Stone Game VIII - Problem

Array Math Dynamic Programming Prefix Sum Game Theory Hard

Alice and Bob take turns playing a game, with Alice starting first.

There are n stones arranged in a row. On each player's turn, while the number of stones is more than one, they will do the following:

Choose an integer x > 1, and remove the leftmost x stones from the row.
Add the sum of the removed stones' values to the player's score.
Place a new stone, whose value is equal to that sum, on the left side of the row.

The game stops when only one stone is left in the row.

The score difference between Alice and Bob is (Alice's score - Bob's score). Alice's goal is to maximize the score difference, and Bob's goal is to minimize the score difference.

Given an integer array stones of length n where stones[i] represents the value of the ith stone from the left, return the score difference between Alice and Bob if they both play optimally.

Input & Output

Example 1 — Small Array

$ Input: stones = [-1,2,-3,4,-5]

› Output: 5

💡 Note: Alice can take the first 4 stones (sum = -1+2+(-3)+4 = 2), then Bob must take the remaining stones [2,-5] (sum = -3), giving Alice advantage of 2-(-3) = 5.

Example 2 — All Positive

$ Input: stones = [7,-6,5,10,5,-2,-6]

› Output: 13

💡 Note: Alice plays optimally to maximize score difference, achieving a final advantage of 13.

Example 3 — Minimum Size

$ Input: stones = [-10,20]

› Output: 10

💡 Note: Alice must take both stones (sum = 10), Bob gets nothing, so difference is 10.

Constraints

3 ≤ stones.length ≤ 10⁴
-10⁴ ≤ stones[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is recognizing this as a minimax game theory problem where we can use dynamic programming with prefix sums. After each move, we have a subarray starting from some position. The optimal approach uses DP with prefix sums where dp[i] represents the maximum score difference achievable from position i. Time: O(n²), Space: O(n)

Common Approaches

✓ Dynamic Programming with Prefix Sums

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

Key insight: After each move, we're left with a subarray starting from some position. We can use dynamic programming where dp[i] represents the maximum score difference Alice can achieve starting from position i, combined with prefix sums for fast range calculations.

Memoized Game Theory

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

Same recursive approach but store results of each game state in a hash map. Since the same stone configuration can be reached through different move sequences, memoization eliminates redundant calculations.

Recursive Game Tree

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

For each turn, try taking 2, 3, 4, ... up to n stones, recursively calculate the optimal score difference for the remaining game, and choose the move that maximizes Alice's advantage or minimizes Bob's advantage.

Dynamic Programming with Prefix Sums — Algorithm Steps

Calculate prefix sums for fast range queries
DP state: maximum advantage from position i onward
Try all valid moves and choose optimal

Visualization

Tap to expand

Step-by-Step Walkthrough

Prefix Sums

Precompute cumulative sums for fast range queries

DP Fill

Fill DP table backwards from end to start

Optimal Choice

Each position chooses move that maximizes advantage

Code -

solution.c — C

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

static long long prefix[10001];
static long long dp[10001];

long long max(long long a, long long b) {
    return a > b ? a : b;
}

long long solution(int* stones, int n) {
    if (n == 2) {
        return stones[0] + stones[1];
    }
    
    // Calculate prefix sums
    prefix[0] = 0;
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + stones[i];
    }
    
    // dp[i] = best score difference current player can achieve starting from position i
    for (int i = 0; i <= n; i++) {
        dp[i] = 0;
    }
    
    // Work backwards from the end
    for (int i = n - 1; i >= 1; i--) {
        // Current player must take at least 2 stones (from position 0 to position i)
        // They get prefix[i+1] points
        // After their move, the opponent plays optimally on remaining game
        dp[i] = prefix[i + 1] - dp[i + 1];
        
        // But current player wants to maximize, so they choose the best option
        if (i < n - 1) {
            dp[i] = max(dp[i], dp[i + 1]);
        }
    }
    
    return dp[1];
}

int main() {
    char line[20000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    int stones[10000];
    int n = 0;
    
    // Parse input manually
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        long val = strtol(p, &p, 10);
        stones[n++] = (int)val;
    }
    
    printf("%lld\n", solution(stones, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop for positions, inner loop for move choices

⚠ Quadratic Growth

Space Complexity

O(n)

DP array and prefix sum array, both of size n

⚠ Quadratic Space

28.5K Views

Medium 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

Dynamic Programming with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler