Stone Game IV - Practice Coding Problems

Stone Game IV - Problem

Stone Game IV - A strategic battle of wits between two optimal players!

Alice and Bob are playing an exciting mathematical game with stones. There are n stones in a pile, and they take turns removing stones with a special twist - on each turn, a player can only remove a perfect square number of stones (1, 4, 9, 16, 25, ...).

Rules:
• Alice goes first
• Players must remove at least 1 stone per turn
• Only perfect square numbers of stones can be removed
• The player who cannot make a move loses
• Both players play optimally

Goal: Determine if Alice can guarantee a win with optimal play.

Example: If there are 7 stones, Alice can remove 4 stones (2²), leaving 3 for Bob. Bob can only remove 1 stone, leaving 2 for Alice. Alice removes 1, Bob removes 1, and Alice wins!

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: true

💡 Note: Alice can remove 1 stone (1²) and Bob cannot make any move, so Alice wins.

example_2.py — Multiple Options

$ Input: n = 7

› Output: false

💡 Note: Alice can remove 1, 4 stones. If she removes 1, Bob faces 6 stones (Bob can win). If she removes 4, Bob faces 3 stones (Bob can win). No winning move for Alice.

example_3.py — Perfect Square

$ Input: n = 17

› Output: false

💡 Note: 17 is not a winning position. No matter what Alice chooses (1, 4, 9, or 16), Bob will be in a winning position.

Visualization

Tap to expand

Understanding the Visualization

Understand the Rules

Players alternate removing perfect square numbers of stones (1, 4, 9, 16, ...)

Winning vs Losing Positions

A position is winning if you can make a move that puts opponent in losing position

Build Solution Bottom-Up

Use DP to determine winning/losing status for each number of stones

Check All Moves

For each position, try all valid perfect square moves

Key Takeaway

🎯 Key Insight: Use dynamic programming to build up winning/losing positions. A position is winning if any move leads to opponent losing!

Time & Space Complexity

Time Complexity

⏱️

O(n√n)

For each of n positions, we check up to √n perfect squares

✓ Linear Growth

Space Complexity

O(n)

DP array to store results for each position from 0 to n

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
Perfect squares only: Players can only remove 1², 2², 3², ... stones
Both players play optimally

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses dynamic programming with time complexity O(n√n). The key insight is that a position is winning if there exists at least one move that puts the opponent in a losing position. We build up the solution from smaller subproblems, checking all perfect square moves for each position.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n√n)	O(n)	Cache results of subproblems to avoid recalculation and achieve optimal time complexity
Recursive Game Theory (Brute Force)	O(√n^n)	O(n)	Recursively explore all possible game states to determine winner

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a DP array where dp[i] represents if current player wins with i stones
Base case: dp[0] = False (no moves possible, current player loses)
For each position i, try all perfect square moves j² where j² ≤ i
If dp[i - j²] is False (opponent loses), then dp[i] = True
Return dp[n] for the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

All positions start as losing (False)

Fill positions 1 to n

For each position, check all perfect square moves

Find winning positions

Position is winning if any move leads to losing position for opponent

Code -

solution.c — C

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

bool winnerSquareGame(int n) {
    // dp[i] represents if current player wins with i stones
    bool* dp = (bool*)calloc(n + 1, sizeof(bool));
    
    // For each number of stones
    for (int i = 1; i <= n; i++) {
        // Try all perfect square moves
        for (int j = 1; j * j <= i; j++) {
            // If opponent loses after our move, we win
            if (!dp[i - j * j]) {
                dp[i] = true;
                break;
            }
        }
    }
    
    bool result = dp[n];
    free(dp);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", winnerSquareGame(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n√n)

For each of n positions, we check up to √n perfect squares

✓ Linear Growth

Space Complexity

O(n)

DP array to store results for each position from 0 to n

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
Perfect squares only: Players can only remove 1², 2², 3², ... stones
Both players play optimally

24.7K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler