Can I Win

Can I Win - Problem

Math Dynamic Programming Bit Manipulation Memoization Game Theory Bitmask Medium

In the "100 game" two players take turns adding, to a running total, any integer from 1 to 10. The player who first causes the running total to reach or exceed 100 wins.

What if we change the game so that players cannot re-use integers? For example, two players might take turns drawing from a common pool of numbers from 1 to 15 without replacement until they reach a total >= 100.

Given two integers maxChoosableInteger and desiredTotal, return true if the first player to move can force a win, otherwise, return false. Assume both players play optimally.

Input & Output

Example 1 — First Player Can Win Immediately

$ Input: maxChoosableInteger = 10, desiredTotal = 11

› Output: false

💡 Note: First player cannot guarantee a win. If player 1 picks any number from 1-10, player 2 can pick a number that reaches or exceeds 11.

Example 2 — Small Numbers, Strategic Play

$ Input: maxChoosableInteger = 10, desiredTotal = 40

› Output: true

💡 Note: First player can force a win by making strategic choices that put the second player in losing positions.

Example 3 — Immediate Win

$ Input: maxChoosableInteger = 5, desiredTotal = 5

› Output: true

💡 Note: First player wins immediately by choosing 5, which reaches the desired total.

Constraints

1 ≤ maxChoosableInteger ≤ 20
0 ≤ desiredTotal ≤ 300

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

This is a game theory problem where we determine if the first player can force a win. The key insight is to use memoization with bit manipulation to represent game states efficiently. Best approach uses memoization with bitmasks. Time: O(2^n × n), Space: O(2^n)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Two Pass

⏱️ Time: N/A Space: N/A

Memoization with Bit Manipulation

⏱️ Time: O(2^n × n) Space: O(2^n)

Represent the set of used numbers as a bitmask and cache results for each unique game state. This eliminates redundant calculations when the same combination of used numbers appears.

Recursive Brute Force

⏱️ Time: O(2^n × n) Space: O(n)

For each possible move, recursively check if the opponent can win from the resulting state. The current player wins if any move leads to the opponent losing.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

98.6K Views

Medium Frequency

~35 min Avg. Time

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