Formatted question description: https://leetcode.ca/all/1025.html

# 1025. Divisor Game (Easy)

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

Initially, there is a number `N`

on the chalkboard. On each player's turn, that player makes a *move* consisting of:

- Choosing any
`x`

with`0 < x < N`

and`N % x == 0`

. - Replacing the number
`N`

on the chalkboard with`N - x`

.

Also, if a player cannot make a move, they lose the game.

Return `True`

if and only if Alice wins the game, assuming both players play optimally.

**Example 1:**

Input:2Output:trueExplanation:Alice chooses 1, and Bob has no more moves.

**Example 2:**

Input:3Output:falseExplanation:Alice chooses 1, Bob chooses 1, and Alice has no more moves.

**Note:**

`1 <= N <= 1000`

**Companies**:

Visa

**Related Topics**:

Math, Dynamic Programming

## Solution 1.

```
// OJ: https://leetcode.com/problems/divisor-game/
// Time: O(N * sqrt(N))
// Space: O(N)
class Solution {
private:
unordered_map<int, bool> m;
public:
bool divisorGame(int N) {
if (N == 1) return false;
if (m.find(N) != m.end()) return m[N];
bool ans = false;
for (int x = sqrt(N); x >= 1 && !ans; --x) {
if (N % x) continue;
if (!divisorGame(N - x)) ans = true;
}
return m[N] = ans;
}
};
```

## Solution 2.

Denote `F(N)`

as the result.

- If
`F(N) = false`

, then`F(N + 1) = true`

. Because for case`N + 1`

, Alice can simply pick`x = 1`

to win. - If
`N`

is odd number, it only have odd factors. So after the first move, it will become even number.

`F(1) = false`

`F(2) = true`

according to Rule #1.`F(3) = false`

since`2`

is the only possible situation for Bob and`F(2) = true`

.`F(4) = true`

according to Rule #1.`F(5) = false`

since all even numbers (`2`

and`4`

) lead to`true`

for Bob.- …

So we can see, even numbers always win; odd numbers lose.

```
// OJ: https://leetcode.com/problems/divisor-game/
// Time: O(1)
// Space: O(1)
// Ref: https://leetcode.com/problems/divisor-game/discuss/274566/just-return-N-2-0-(proof)
class Solution {
public:
bool divisorGame(int N) {
return N % 2 == 0;
}
};
```

Java

```
class Solution {
public boolean divisorGame(int N) {
boolean[] dp = new boolean[N + 1];
for (int i = 1; i <= N; i++) {
for (int j = 1; j < i; j++) {
if (i % (i - j) == 0 && !dp[j]) {
dp[i] = true;
break;
}
}
}
return dp[N];
}
}
```