Codestin Search App

Stone Game VIII - Problem

Array Math Dynamic Programming Prefix Sum Game Theory Hard

Stone Game VIII is an advanced strategic game theory problem where Alice and Bob compete optimally to maximize their score difference.

🎮 Game Rules:
• Alice starts first, players alternate turns
• On each turn, a player chooses x > 1 and removes the leftmost x stones
• The player's score increases by the sum of those removed stones
• A new stone with value equal to that sum is placed at the leftmost position
• Game continues until only one stone remains

🎯 Objective: Alice wants to maximize the score difference (Alice's score - Bob's score), while Bob wants to minimize it. Both play optimally.

Input: An array stones representing stone values from left to right
Output: The final score difference when both players play optimally

Input & Output

example_1.py — Basic Game

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

› Output: 5

💡 Note: Alice takes stones [0,1,2,3] with sum 2, gaining 2 points. Bob must take the remaining stones [-5, 2] with sum -3, losing 3 points. Final difference: 2 - (-3) = 5.

example_2.py — Simple Case

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

› Output: 13

💡 Note: Alice optimally takes stones to maximize her advantage. Through optimal play, she can achieve a score difference of 13.

example_3.py — Minimum Length

$ Input: stones = [20, 3]

› Output: 23

💡 Note: With only 2 stones, Alice must take both stones. Her score is 20 + 3 = 23, Bob scores 0, so the difference is 23.

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Calculate prefix sums for instant range sum queries - like having a calculator that instantly knows the sum of any consecutive stones

Strategic Planning

Build DP table backwards from endgame positions - like chess players analyzing positions from checkmate backwards

Move Evaluation

For each position, evaluate all legal moves (taking 2+ stones) and choose the one maximizing advantage

Optimal Play

Both players make their best possible moves based on perfect knowledge of resulting positions

Key Takeaway

🎯 Key Insight: Game theory problems can be solved efficiently using dynamic programming with memoization, transforming exponential complexity into polynomial time by avoiding redundant state calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We process each position once and try at most n moves from each position

⚠ Quadratic Growth

Space Complexity

O(n)

DP array and prefix sum array both use O(n) space

⚡ Linearithmic Space

Constraints

n == stones.length
2 ≤ n ≤ 1000
-1000 ≤ stones[i] ≤ 1000
Alice always moves first
Both players play optimally

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses dynamic programming with prefix sums to efficiently calculate the maximum score difference. The key insight is working backwards from end states and using prefix sums for O(1) range queries, achieving O(n²) time complexity instead of exponential brute force.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized DP with Prefix Sums	O(n²)	O(n)	Dynamic programming solution using prefix sums for efficient computation

Optimized DP with Prefix Sums — Algorithm Steps

Calculate prefix sums for O(1) range sum queries
Initialize DP array where dp[i] represents the optimal score difference when considering stones from index i onwards
Work backwards from the end, considering all valid moves at each position
For each position, try taking x stones (where x >= 2) and calculate the resulting score
Use the recurrence: dp[i] = max(prefix[j] - dp[next_state]) for all valid j
Return dp[0] which represents the optimal score difference from the initial state

Visualization

Tap to expand

Step-by-Step Walkthrough

Prefix Sums

Calculate cumulative sums for O(1) range queries

DP Table

Build DP table working backwards from end states

State Transitions

For each position, try all valid moves and choose optimal

Final Answer

Return optimal score difference from initial state

Code -

solution.c — C

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

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

int stoneGameVIII(int* stones, int stonesSize) {
    int n = stonesSize;
    if (n <= 2) {
        long long sum = 0;
        for (int i = 0; i < n; i++) {
            sum += stones[i];
        }
        return (int)sum;
    }
    
    // Calculate prefix sums
    long long* prefix = (long long*)calloc(n + 1, sizeof(long long));
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + stones[i];
    }
    
    // dp[i] represents the maximum score difference 
    // when the game starts from position i onwards
    long long* dp = (long long*)calloc(n, sizeof(long long));
    
    // Base case: when we have only 2 stones left
    dp[n - 1] = prefix[n];  // sum of all remaining stones
    
    // Work backwards
    for (int i = n - 2; i >= 1; i--) {
        dp[i] = LLONG_MIN;
        
        // Try taking stones from position i to j (inclusive)
        for (int j = i + 1; j < n; j++) {
            // Score gained = sum from position i to j
            long long scoreGained = prefix[j + 1] - prefix[i];
            
            if (j == n - 1) {  // Game ends after this move
                dp[i] = max(dp[i], scoreGained);
            } else {
                // Opponent plays optimally from position j+1
                dp[i] = max(dp[i], scoreGained - dp[j + 1]);
            }
        }
    }
    
    // The answer is the optimal play starting from position 0
    long long result = LLONG_MIN;
    for (int j = 1; j < n; j++) {
        long long scoreGained = prefix[j + 1];  // sum from 0 to j
        if (j == n - 1) {  // Game ends
            result = max(result, scoreGained);
        } else {
            result = max(result, scoreGained - dp[j + 1]);
        }
    }
    
    free(prefix);
    free(dp);
    return (int)result;
}

int main() {
    int stones[1000];
    int n = 0;
    char c;
    int num = 0;
    int negative = 0;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (c == '-') {
            negative = 1;
            reading = 1;
        } else if (reading) {
            stones[n++] = negative ? -num : num;
            num = 0;
            negative = 0;
            reading = 0;
        }
    }
    if (reading) {
        stones[n++] = negative ? -num : num;
    }
    
    printf("%d\n", stoneGameVIII(stones, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We process each position once and try at most n moves from each position

⚠ Quadratic Growth

Space Complexity

O(n)

DP array and prefix sum array both use O(n) space

⚡ Linearithmic Space

Constraints

n == stones.length
2 ≤ n ≤ 1000
-1000 ≤ stones[i] ≤ 1000
Alice always moves first
Both players play optimally

34.2K Views

Medium Frequency

~35 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized DP with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler