Stone Game IV

Stone Game IV - Problem

Alice and Bob take turns playing a game, with Alice starting first.

Initially, there are n stones in a pile. On each player's turn, that player makes a move consisting of removing any non-zero square number of stones in the pile.

Also, if a player cannot make a move, he/she loses the game.

Given a positive integer n, return true if and only if Alice wins the game otherwise return false, assuming both players play optimally.

Input & Output

Example 1 — Alice Wins

$ Input: n = 1

› Output: true

💡 Note: Alice can remove 1² = 1 stone, leaving 0 stones for Bob. Bob cannot make a move and loses.

Example 2 — Alice Loses

$ Input: n = 2

› Output: false

💡 Note: Alice can remove 1² = 1 stone, leaving 1 stone for Bob. Bob removes 1² = 1 stone, leaving 0 for Alice. Alice cannot make a move and loses.

Example 3 — Complex Case

$ Input: n = 4

› Output: true

💡 Note: Alice can remove 4 stones (2²=4), leaving 0 for Bob. Or remove 1 stone leaving 3 for Bob. Alice has winning moves.

Constraints

1 ≤ n ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 a Amazon 8

The key insight is that this is a classic game theory problem solvable with dynamic programming. A position is winning if there exists at least one move that leads to a losing position for the opponent. Best approach is bottom-up DP building from base cases. Time: O(n√n), Space: O(n).

Common Approaches

✓ Dynamic Programming (Bottom-up)

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

Create a DP array where dp[i] represents whether the current player can win with i stones. Build from dp[0] = false upward.

Memoized Recursion

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

Same recursive logic but store results in a cache to avoid redundant calculations. Each position n is calculated only once.

Recursive Brute Force

⏱️ Time: O(n^(3/2)) Space: O(√n)

For each position, try removing every possible square number of stones and recursively check if opponent loses. If any move leads to opponent losing, current player wins.

Dynamic Programming (Bottom-up) — Algorithm Steps

Create DP array with dp[0] = false
For each position i, try all square moves
dp[i] = true if any move leads to dp[remaining] = false

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

dp[0] = false (no moves possible)

Fill DP Array

For each i, check if any square move leads to losing position

Final Answer

dp[n] contains the answer

Code -

solution.c — C

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

bool solution(int n) {
    bool* dp = (bool*)calloc(n + 1, sizeof(bool));
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j * j <= i; j++) {
            if (!dp[i - j * j]) {
                dp[i] = true;
                break;
            }
        }
    }
    
    bool result = dp[n];
    free(dp);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    bool result = solution(n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n√n)

For each position i (0 to n), try all squares up to √i, totaling n√n operations

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store winning state for each position

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

856 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 (Bottom-up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler