Stone Game VII - Practice Coding Problems

Stone Game VII - Problem

Stone Game VII is a strategic two-player game where Alice and Bob compete for the highest score by removing stones from the ends of a row.

🎮 Game Rules:
• Players alternate turns, with Alice going first
• On each turn, a player removes either the leftmost or rightmost stone
• The player's score increases by the sum of all remaining stones after removal
• The game ends when no stones remain

🎯 The Twist: Bob knows he'll lose, so he plays to minimize the score difference. Alice wants to maximize the difference.

Your Task: Given an array stones where stones[i] is the value of the i-th stone, return the maximum score difference Alice can achieve when both players play optimally.

Example: With stones [5,3,1,4,2], Alice can achieve a score difference of 6 through optimal play.

Input & Output

example_1.py — Python

$ Input: [5,3,1,4,2]

› Output: 6

💡 Note: Alice removes 5, remaining sum = 10, Alice scores 10. Bob removes 2, remaining sum = 6, Bob scores 6. Alice removes 4, remaining sum = 4, Alice scores 4. Bob removes 1, remaining sum = 3, Bob scores 3. Alice removes 3, game ends. Alice total = 14, Bob total = 9, difference = 5. But with optimal play, Alice can achieve difference of 6.

example_2.py — Python

$ Input: [7,90,5,1,100,10,10,2]

› Output: 122

💡 Note: In this larger game, Alice can achieve a score difference of 122 through optimal stone removal strategy.

example_3.py — Python

$ Input: [1,2]

› Output: 1

💡 Note: Alice removes 1, gets score 2. Bob removes 2, gets score 0. Difference is 2-0=2. If Alice removes 2 first, she gets score 1, Bob gets 0. Alice chooses the first option for difference of 2. Wait - let me recalculate: Alice removes stone worth 1, remaining stones have sum 2, so Alice scores 2. Bob removes stone worth 2, no stones remain, Bob scores 0. Alice advantage = 2-0 = 2. Actually, if Alice removes 2 first, remaining sum is 1, Alice scores 1. Bob removes 1, remaining sum 0, Bob scores 0. Alice advantage = 1-0 = 1. So Alice chooses first option, but the correct answer should be 1 based on optimal play from both sides.

Constraints

n == stones.length
2 ≤ n ≤ 1000
1 ≤ stones[i] ≤ 1000
Both players play optimally - Alice maximizes difference, Bob minimizes it

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Players face a row of stones, can only take from ends

Score Calculation

When removing a stone, player scores the sum of all remaining stones

Optimal Strategy

Alice maximizes score difference, Bob minimizes it

DP Solution

Use memoization to efficiently explore all possible game states

Key Takeaway

🎯 Key Insight: This is a classic minimax game theory problem where we use dynamic programming to efficiently explore all possible game states, with each player making optimal decisions from their perspective.

Asked in

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

The optimal solution uses dynamic programming with memoization to solve this classic game theory problem. Key insights: (1) Each player optimizes from their own perspective, (2) Use prefix sums for O(1) range sum queries, (3) The recurrence relation is dp[i][j] = max(sum[i+1][j] - dp[i+1][j], sum[i][j-1] - dp[i][j-1]), and (4) Memoization reduces time complexity from O(2^n) to O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Dynamic Programming	O(n²)	O(n²)	Cache results of subproblems to avoid recomputation

Memoized Dynamic Programming — Algorithm Steps

Create a memoization table indexed by (left, right) boundaries
For each recursive call, check if result is already cached
If not cached, calculate result using the recursive formula
Store the result in cache before returning
Reuse cached results for identical subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create 2D memo table for all (left,right) pairs

Fill Base Cases

Single stone subarrays have score difference 0

Build Up Solutions

Solve larger ranges using smaller cached results

Reuse Results

Each subproblem solved exactly once

Code -

solution.c — C

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

int memo[1000][1000];
int prefix[1001];

int helper(int left, int right) {
    if (left == right) {
        return 0;
    }
    
    if (memo[left][right] != INT_MIN) {
        return memo[left][right];
    }
    
    int leftSum = prefix[right + 1] - prefix[left + 1];
    int rightSum = prefix[right] - prefix[left];
    
    int leftChoice = leftSum - helper(left + 1, right);
    int rightChoice = rightSum - helper(left, right - 1);
    
    memo[left][right] = leftChoice > rightChoice ? leftChoice : rightChoice;
    return memo[left][right];
}

int stoneGameVII(int* stones, int stonesSize) {
    for (int i = 0; i < stonesSize; i++) {
        prefix[i + 1] = prefix[i] + stones[i];
        for (int j = 0; j < stonesSize; j++) {
            memo[i][j] = INT_MIN;
        }
    }
    
    return helper(0, stonesSize - 1);
}

int main() {
    int stones[] = {5, 3, 1, 4, 2};
    int size = 5;
    printf("%d\n", stoneGameVII(stones, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

There are O(n²) unique subproblems (left, right pairs), each solved once

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores results for all (left, right) pairs plus recursion stack

⚠ Quadratic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Memoized Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler