Stone Game V

Stone Game V - Problem

There are several stones arranged in a row, and each stone has an associated value which is an integer given in the array stoneValue.

In each round of the game, Alice divides the row into two non-empty rows (i.e. left row and right row), then Bob calculates the value of each row which is the sum of the values of all the stones in this row. Bob throws away the row which has the maximum value, and Alice's score increases by the value of the remaining row. If the value of the two rows are equal, Bob lets Alice decide which row will be thrown away.

The next round starts with the remaining row.

The game ends when there is only one stone remaining. Alice's score is initially zero.

Return the maximum score that Alice can obtain.

Input & Output

Example 1 — Basic Game

$ Input: stoneValue = [6,2,3,4,5,5]

› Output: 18

💡 Note: Alice can split at index 2: left=[6,2,3]=11, right=[4,5,5]=14. Bob takes 14, Alice gets 11. Continue with [6,2,3] to get total score 18.

Example 2 — Small Array

$ Input: stoneValue = [7,7,7,7,7,7,7]

› Output: 28

💡 Note: All stones have equal value. Alice can make strategic splits to maximize her remaining portions, achieving a total score of 28.

Example 3 — Minimum Size

$ Input: stoneValue = [4]

› Output: 0

💡 Note: Only one stone remaining, game ends immediately. Alice's score is 0.

Constraints

1 ≤ stoneValue.length ≤ 500
1 ≤ stoneValue[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that Alice wants to maximize her total score by choosing splits that give her the best remaining options after Bob's greedy choice. The optimal approach uses dynamic programming to consider all possible game states. Time: O(n³), Space: O(n²)

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Use 2D DP table where dp[i][j] represents maximum score Alice can get from subarray stones[i:j+1]. Fill table bottom-up by considering all possible split points for each subarray length.

Memoized Recursion

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

Same recursive approach as brute force, but store results of each (left, right) subarray in a cache. When the same subarray is encountered again, return the cached result instead of recalculating.

Recursive Brute Force

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

For each subarray, try every possible split point. Bob takes the larger sum, Alice gets the smaller sum plus the best score from the remaining subarray. This explores all possibilities but recalculates the same subarrays multiple times.

Bottom-Up Dynamic Programming — Algorithm Steps

Create 2D DP table dp[i][j] for subarray from i to j
Build prefix sum array for O(1) range queries
Fill DP table by increasing subarray length
For each subarray, try all split points
Choose split that maximizes Alice's total score

Visualization

Tap to expand

Step-by-Step Walkthrough

Length 2

Fill DP for all 2-element subarrays

Length 3

Build 3-element subarrays using 2-element results

Full Array

Final answer at dp[0][n-1]

Code -

solution.c — C

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

int solution(int* stoneValue, int size) {
    int n = size;
    if (n <= 1) return 0;
    
    // Prefix sum for O(1) range sum queries
    int prefix[n + 1];
    prefix[0] = 0;
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + stoneValue[i];
    }
    
    // DP table: dp[i][j] = max score from subarray [i, j]
    int dp[n][n];
    memset(dp, 0, sizeof(dp));
    
    // Fill DP table by increasing subarray length
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            int total = prefix[j + 1] - prefix[i];
            
            // Try all possible split points
            for (int k = i; k < j; k++) {
                int leftSum = prefix[k + 1] - prefix[i];
                int rightSum = total - leftSum;
                
                int score;
                if (leftSum < rightSum) {
                    score = leftSum + dp[i][k];
                } else if (leftSum > rightSum) {
                    score = rightSum + dp[k + 1][j];
                } else {
                    int leftOption = dp[i][k];
                    int rightOption = dp[k + 1][j];
                    score = leftSum + (leftOption > rightOption ? leftOption : rightOption);
                }
                
                if (score > dp[i][j]) {
                    dp[i][j] = score;
                }
            }
        }
    }
    
    return dp[0][n - 1];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int stoneValue[500];
    int size = 0;
    
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        stoneValue[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int result = solution(stoneValue, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: length, start position, and split point

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table stores results for all O(n²) subarrays

⚠ Quadratic Space

28.0K 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

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler