Can I Win - Practice Coding Problems

Can I Win - Problem

Math Dynamic Programming Bit Manipulation Memoization Game Theory Bitmask Medium

Welcome to the "Can I Win" strategy game! This is a fascinating twist on the classic number-picking game where two players compete to reach a target total, but with a crucial constraint: no number can be used twice.

The Game Rules:

Two players take turns picking integers from 1 to maxChoosableInteger
Each number can only be used once (no replacement)
Numbers are added to a running total
The first player to make the total reach or exceed desiredTotal wins
Both players play optimally (always make the best possible move)

Your Task: Determine if the first player can guarantee a win with optimal play. Return true if the first player has a winning strategy, false otherwise.

Example: With numbers 1-10 and target 11, the first player can pick 10, then no matter what the second player picks (1-9), the first player can reach 11+ on their next turn!

Input & Output

example_1.py — Small Numbers, Easy Win

$ Input: maxChoosableInteger = 10, desiredTotal = 11

› Output: true

💡 Note: The first player can pick 10, then regardless of what the second player picks (1-9), the first player can always reach 11 on their next turn. For example: First player picks 10, second player picks any number (say 3), first player picks 1 and wins with total 11.

example_2.py — Impossible Target

$ Input: maxChoosableInteger = 10, desiredTotal = 40

› Output: false

💡 Note: The sum of all numbers from 1 to 10 is 55. Even if the first player could use all numbers optimally, they cannot guarantee a win because the second player also plays optimally. Through game theory analysis, the second player has a winning strategy in this scenario.

example_3.py — Immediate Win

$ Input: maxChoosableInteger = 20, desiredTotal = 15

› Output: true

💡 Note: The first player wins immediately by picking any number >= 15. Since maxChoosableInteger (20) >= desiredTotal (15), the first player can choose 15, 16, 17, 18, 19, or 20 to win on the first move.

Visualization

Tap to expand

Understanding the Visualization

Game Setup

Available numbers: {1, 2, 3, 4}, Target: 6. First player must choose wisely.

Optimal First Move

First player picks 4. Now second player faces {1, 2, 3} with target 2.

Second Player's Dilemma

Any choice by second player (1, 2, or 3) leaves first player with a winning move.

Guaranteed Victory

First player can always complete the remaining target on their next turn.

Key Takeaway

🎯 Key Insight: Use memoized game theory with bitmask representation. The optimal strategy involves trying each possible move and recursively checking if the opponent can win from the resulting state, while caching results to avoid recomputation.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

There are 2^n possible game states (bitmasks), and for each state we try at most n moves, but each state is computed only once

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for up to 2^n different game states

⚠ Quadratic Space

Constraints

1 <= maxChoosableInteger <= 20
0 <= desiredTotal <= 300
Both players play optimally
Numbers from 1 to maxChoosableInteger can each be used at most once

Asked in

G Google 28 ⊞ Microsoft 22 a Amazon 15 f Meta 12

The optimal solution uses memoized game theory with bitmask representation. Each game state is represented by a bitmask showing which numbers are used, and we cache results to avoid recomputation. The key insight is that we only need to track which numbers are available (not the current total) since we can calculate the remaining target. Time complexity is O(2^n × n) where each of the 2^n possible states is computed once.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Game Theory (Optimal)	O(2^n * n)	O(2^n)	Use memoization with bitmask to cache game state results and avoid recomputation
Recursive Game Tree (No Memoization)	O(2^n * n)	O(n)	Explore all possible game scenarios recursively without caching results

Memoized Game Theory (Optimal) — Algorithm Steps

Represent game state using bitmask (bit i set means number i+1 is used)
For each state, check if current player can win immediately
Try each available move and recursively check if opponent loses
Cache results using the bitmask as key to avoid recomputation
Return cached result if state has been seen before

Visualization

Tap to expand

Step-by-Step Walkthrough

State Representation

Each game state is represented by a bitmask showing used numbers

First Calculation

Calculate result for a game state and cache it

Cache Hit

When same state appears again, return cached result immediately

Pruned Tree

Memoization dramatically reduces the search space

Code -

solution.c — C

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

#define MAX_STATES 100000

typedef struct {
    int mask;
    bool result;
} MemoEntry;

MemoEntry memo[MAX_STATES];
int memoSize = 0;

bool findMemo(int mask, bool* result) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].mask == mask) {
            *result = memo[i].result;
            return true;
        }
    }
    return false;
}

void addMemo(int mask, bool result) {
    if (memoSize < MAX_STATES) {
        memo[memoSize].mask = mask;
        memo[memoSize].result = result;
        memoSize++;
    }
}

bool canWinHelper(int usedMask, int remainingTotal, int maxChoosableInteger) {
    bool cached;
    if (findMemo(usedMask, &cached)) {
        return cached;
    }
    
    // Try each unused number
    for (int i = 0; i < maxChoosableInteger; i++) {
        if (!(usedMask & (1 << i))) {  // if number i+1 is not used
            int number = i + 1;
            
            // If this move wins the game
            if (number >= remainingTotal) {
                addMemo(usedMask, true);
                return true;
            }
            
            // Try this move and see if opponent loses
            int newMask = usedMask | (1 << i);
            if (!canWinHelper(newMask, remainingTotal - number, maxChoosableInteger)) {
                addMemo(usedMask, true);
                return true;
            }
        }
    }
    
    addMemo(usedMask, false);
    return false;
}

bool canIWin(int maxChoosableInteger, int desiredTotal) {
    memoSize = 0;  // Reset memo
    
    // Edge case: if max number >= target, first player wins immediately
    if (maxChoosableInteger >= desiredTotal) {
        return true;
    }
    
    // If sum of all numbers < target, no one can win
    int totalSum = maxChoosableInteger * (maxChoosableInteger + 1) / 2;
    if (totalSum < desiredTotal) {
        return false;
    }
    
    return canWinHelper(0, desiredTotal, maxChoosableInteger);
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

There are 2^n possible game states (bitmasks), and for each state we try at most n moves, but each state is computed only once

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for up to 2^n different game states

⚠ Quadratic Space

Constraints

1 <= maxChoosableInteger <= 20
0 <= desiredTotal <= 300
Both players play optimally
Numbers from 1 to maxChoosableInteger can each be used at most once

63.4K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Memoized Game Theory (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler