Stone Game II - Practice Coding Problems

Stone Game II - Problem

Array Math Dynamic Programming Prefix Sum Game Theory Medium

🎮 Welcome to Stone Game II! Alice and Bob are back for another strategic stone-collecting battle. This time, the rules have evolved to create an even more engaging game of wits.

The Setup: There are several piles of stones arranged in a row, where piles[i] represents the number of stones in the i-th pile. Alice goes first, and both players want to maximize their own stone collection.

The Rules:

Players take turns, with Alice starting first
On each turn, a player can take all stones from the first X remaining piles, where 1 ≤ X ≤ 2M
After taking X piles, we update M = max(M, X)
Initially, M = 1
The game continues until all piles are taken

Your Goal: Assuming both Alice and Bob play optimally (making the best possible moves), determine the maximum number of stones Alice can collect.

Example: If piles = [2,7,9,4,4], Alice can strategically collect 10 stones while Bob gets 6 stones, even though Alice goes first and faces optimal opposition!

Input & Output

example_1.py — Basic Game

$ Input: piles = [2,7,9,4,4]

› Output: 10

💡 Note: Alice starts with M=1. She can take 1 pile (gets 2) or 2 piles (gets 2+7=9). If she takes 2 piles, M becomes 2, and Bob can then take up to 4 piles from [9,4,4]. Bob will take all remaining piles (getting 17), leaving Alice with only 9. So Alice should take just 1 pile (gets 2), then Bob takes optimally, and through strategic play, Alice ends up with 10 stones total.

example_2.py — Small Array

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

› Output: 104

💡 Note: Alice can strategically force the game so that she gets the pile with 100 stones plus some others. The optimal play leads to Alice collecting 104 stones while Bob gets the remaining stones.

example_3.py — Edge Case

$ Input: piles = [1]

› Output: 1

💡 Note: With only one pile, Alice takes it all on her first turn since 1 ≤ 2×1. Alice gets 1 stone, Bob gets 0.

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Alice and Bob face stone piles, M starts at 1

Strategic Thinking

Each player considers all legal moves (1 to 2M piles)

Advantage Calculation

Players choose moves that maximize their total minus opponent's total

Dynamic Adaptation

M grows with larger moves, opening up more possibilities

Key Takeaway

🎯 Key Insight: Transform the problem from "maximize my stones" to "maximize my advantage over opponent" using suffix sums and memoization to achieve optimal O(n³) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

We have O(n²) possible states (n positions × n values of M), and for each state we try O(n) moves

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores results for O(n²) states, plus O(n) for suffix sums

⚠ Quadratic Space

Constraints

1 ≤ piles.length ≤ 100
1 ≤ piles[i] ≤ 10⁴
Both players play optimally
Alice starts first
Initially M = 1

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal solution uses memoized dynamic programming with suffix sums. Key insights: (1) Use suffix sums for O(1) range queries, (2) Memoize (position, M) states to avoid recalculation, (3) Apply minimax principle - each player maximizes their advantage over the opponent. Time: O(n³), Space: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Dynamic Programming (Optimal)	O(n³)	O(n²)	Use memoization with suffix sums to avoid recalculating game states

Memoized Dynamic Programming (Optimal) — Algorithm Steps

Pre-calculate suffix sums for quick range sum queries
Create memoization table for (position, M) states
For each state, try all valid moves (1 to 2M piles)
Use minimax principle: maximize current player's advantage
Store and reuse results to avoid redundant calculations

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Suffix Sums

Pre-calculate sums from each position to end

Memoize States

Store results for (position, M) combinations

Try All Moves

For each state, try taking 1 to 2M piles

Maximize Advantage

Choose move that maximizes current player's advantage

Code -

solution.c — C

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

#define MAXN 105

int suffixSum[MAXN];
int memo[MAXN][MAXN];
int n;

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

int dp(int i, int M) {
    if (i >= n) return 0;
    if (memo[i][M] != -1) return memo[i][M];
    
    if (i + 2 * M >= n) {
        return memo[i][M] = suffixSum[i];
    }
    
    int best = 0;
    for (int X = 1; X <= 2 * M; X++) {
        int opponentBest = dp(i + X, max(M, X));
        int currentAdvantage = suffixSum[i] - opponentBest;
        best = max(best, currentAdvantage);
    }
    
    return memo[i][M] = best;
}

int stoneGameII(int* piles, int pilesSize) {
    n = pilesSize;
    
    // Calculate suffix sums
    suffixSum[n] = 0;
    for (int i = n - 1; i >= 0; i--) {
        suffixSum[i] = suffixSum[i + 1] + piles[i];
    }
    
    // Initialize memo
    memset(memo, -1, sizeof(memo));
    
    return dp(0, 1);
}

int main() {
    int piles[MAXN];
    int pilesSize = 0;
    char c;
    
    scanf("%c", &c); // [
    while (scanf("%d%c", &piles[pilesSize], &c)) {
        pilesSize++;
        if (c == ']') break;
    }
    
    printf("%d\n", stoneGameII(piles, pilesSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

We have O(n²) possible states (n positions × n values of M), and for each state we try O(n) moves

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores results for O(n²) states, plus O(n) for suffix sums

⚠ Quadratic Space

Constraints

1 ≤ piles.length ≤ 100
1 ≤ piles[i] ≤ 10⁴
Both players play optimally
Alice starts first
Initially M = 1

43.7K Views

Medium Frequency

~25 min Avg. Time

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

Memoized Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler