Stone Game VII

Stone Game VII - Problem

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, they can remove either the leftmost stone or the rightmost stone from the row and receive points equal to the sum of the remaining stones' values in the row.

The winner is the one with the higher score when there are no stones left to remove.

Bob found that he will always lose this game (poor Bob, he always loses), so he decided to minimize the score's difference. Alice's goal is to maximize the difference in the score.

Given an array of integers stones where stones[i] represents the value of the ith stone from the left, return the difference in Alice and Bob's score if they both play optimally.

Input & Output

Example 1 — Basic Game

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

› Output: 6

💡 Note: Alice starts and plays optimally. One optimal sequence: Alice removes 2 (scores 5+3+1+4=13), Bob removes 5 (scores 3+1+4=8), Alice removes 4 (scores 3+1=4), Bob removes 1 (scores 3), Alice takes 3 (scores 0). Alice: 13+4=17, Bob: 8+3=11. Difference: 17-11=6.

Example 2 — Small Array

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

› Output: 122

💡 Note: With optimal play from both players, Alice can achieve a score difference of 122 points.

Example 3 — Minimum Size

$ Input: stones = [3,7]

› Output: 7

💡 Note: Alice can remove 3 (gets score 7) or remove 7 (gets score 3). She chooses to remove 3, then Bob must take 7 (gets score 0). Alice: 7, Bob: 0. Difference: 7-0=7.

Constraints

n == stones.length
2 ≤ n ≤ 1000
1 ≤ stones[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 f Facebook 6

The key insight is that this is a classic game theory problem where each player tries to optimize their own advantage. The optimal approach uses dynamic programming where dp[i][j] represents the maximum score difference achievable in range [i,j]. Time: O(n²), Space: O(n²)

Common Approaches

✓ Bottom-up Dynamic Programming

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

Instead of recursion, build up solutions from smaller ranges to larger ones. dp[i][j] represents the maximum score difference the current player can achieve in range [i,j].

Memoized Recursion

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

Same recursive approach as brute force, but cache results for each [left, right] range to avoid redundant calculations. This dramatically improves performance.

Recursive Brute Force

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

For each game state, try both moves (remove left or right stone) and recursively calculate the optimal score difference. Alice maximizes the difference while Bob minimizes it.

Bottom-up Dynamic Programming — Algorithm Steps

Step 1: Create 2D DP table where dp[i][j] = max advantage for range [i,j]
Step 2: Fill base cases: dp[i][i] = 0 (no advantage when one stone left)
Step 3: For each range length, try both moves and pick the better one
Step 4: Return dp[0][n-1] for the full range

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create 2D DP table, base cases are 0

Fill by Length

Process ranges of length 2, 3, 4... up to n

Choose Best Move

For each range, pick move with maximum advantage

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 solution(int* stones, int n) {
    if (n <= 1) return 0;
    
    // Compute prefix sums for quick range sum queries
    int* prefixSum = (int*)calloc(n + 1, sizeof(int));
    for (int i = 0; i < n; i++) {
        prefixSum[i + 1] = prefixSum[i] + stones[i];
    }
    
    // dp[i][j] = maximum score difference current player can achieve in range [i,j]
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Fill DP table for increasing range lengths
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            
            // Option 1: Remove left stone
            int sumAfterLeft = prefixSum[j + 1] - prefixSum[i + 1];
            int scoreLeft = sumAfterLeft - dp[i + 1][j];
            
            // Option 2: Remove right stone
            int sumAfterRight = prefixSum[j] - prefixSum[i];
            int scoreRight = sumAfterRight - dp[i][j - 1];
            
            // Choose the move that maximizes current player's advantage
            dp[i][j] = max(scoreLeft, scoreRight);
        }
    }
    
    int result = dp[0][n - 1];
    
    // Clean up
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    free(prefixSum);
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int stones[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            stones[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(stones, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterate over all O(n²) range pairs

✓ Linear Growth

Space Complexity

O(n²)

DP table stores results for all n×n range combinations

⚡ Linearithmic Space

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

Bottom-up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler