Stone Game V - Practice Coding Problems

Stone Game V - Problem

Stone Game V presents an exciting strategic challenge where Alice and Bob play an optimal game with stones arranged in a row.

Here's how it works:
• Setup: Stones are arranged in a row, each with a specific value
• Alice's Turn: She divides the row into two non-empty parts (left and right)
• Bob's Turn: He calculates the sum of each part and throws away the part with higher sum
• Tie Breaking: If sums are equal, Alice chooses which part to keep
• Scoring: Alice gains points equal to the sum of the remaining part
• Continue: The game continues with the remaining stones until only one stone is left

Your goal is to find the maximum score Alice can achieve when both players play optimally. This is a classic dynamic programming problem that requires thinking recursively about optimal subproblems.

Input & Output

example_1.py — Basic Game

$ Input: [6,2,3,4,7,9]

› Output: 18

💡 Note: Alice can achieve maximum score 18. One optimal sequence: divide into [6] and [2,3,4,7,9] (sums 6 vs 25), Bob removes [2,3,4,7,9], Alice gets 6. Continue with remaining stones to get total score 18.

example_2.py — Equal Sums

$ Input: [7,7,7,7,7,7,7]

› Output: 28

💡 Note: With all stones having equal value, Alice can always create equal sums and choose which part to keep, allowing her to maximize her total score across all rounds.

example_3.py — Two Stones Only

$ Input: [4,6]

› Output: 4

💡 Note: Alice must split into [4] and [6]. Bob removes the larger sum [6], so Alice gets 4 points. Game ends since only one stone remains.

Constraints

2 ≤ stoneValue.length ≤ 500
1 ≤ stoneValue[i] ≤ 10⁶
Array represents stones arranged in a row from left to right

Visualization

Tap to expand

Understanding the Visualization

Strategic Division

Alice analyzes all possible ways to split the stones, considering Bob's optimal response

Bob's Greedy Choice

Bob always removes the pile with higher sum (or Alice chooses if sums are equal)

Recursive Optimization

Apply the same strategy recursively to remaining stones

Memoization Magic

Cache results to avoid recalculating the same game states

Key Takeaway

🎯 Key Insight: Stone Game V is solved optimally using dynamic programming with memoization, where Alice's strategy for any range depends on optimal solutions for all possible sub-ranges created by her divisions.

Asked in

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

The optimal approach uses dynamic programming with memoization to solve this game theory problem. Key insights: use prefix sums for O(1) range calculations, cache results for overlapping subproblems, and recognize that Alice's optimal strategy depends on optimal solutions for smaller ranges. Time complexity: O(n³), Space complexity: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n³)	O(n²)	Cache recursive results to avoid recalculating the same subproblems

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create prefix sums array for O(1) range sum calculations
Use memoization (cache) to store results for each range [left, right]
For each range, try all possible divisions and calculate optimal scores
Use cached results for overlapping subproblems
Return the maximum score Alice can achieve

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sums

Create prefix sum array for O(1) range queries

Initialize Cache

Set up memoization table to store results

Recursive Calls

Make recursive calls, checking cache first

Store Results

Cache results before returning them

Optimal Score

Return the maximum score Alice can achieve

Code -

solution.c — C

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

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

int* prefix;
int** memo;
int n;

int getSum(int left, int right) {
    return prefix[right + 1] - prefix[left];
}

int dp(int left, int right) {
    if (left == right) return 0;
    if (memo[left][right] != -1) return memo[left][right];
    
    int maxScore = 0;
    
    for (int i = left; i < right; i++) {
        int leftSum = getSum(left, i);
        int rightSum = getSum(i + 1, right);
        
        int score;
        if (leftSum < rightSum) {
            score = leftSum + dp(left, i);
        } else if (leftSum > rightSum) {
            score = rightSum + dp(i + 1, right);
        } else {
            score = leftSum + max(dp(left, i), dp(i + 1, right));
        }
        
        maxScore = max(maxScore, score);
    }
    
    return memo[left][right] = maxScore;
}

int stoneGameV(int* stoneValue, int size) {
    n = size;
    
    // Allocate prefix array
    prefix = (int*)calloc(n + 1, sizeof(int));
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + stoneValue[i];
    }
    
    // Allocate memo array
    memo = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        memo[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            memo[i][j] = -1;
        }
    }
    
    int result = dp(0, n - 1);
    
    // Free memory
    free(prefix);
    for (int i = 0; i < n; i++) {
        free(memo[i]);
    }
    free(memo);
    
    return result;
}

int main() {
    int size;
    scanf("%d", &size);
    int* stones = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        scanf("%d", &stones[i]);
    }
    printf("%d\n", stoneGameV(stones, size));
    free(stones);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) possible ranges, each taking O(n) time to try all divisions

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores results for all possible ranges plus prefix sum array

⚠ Quadratic Space

23.6K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler