Can I win LT464

In the "100 game," two players take turns adding, to a running total, any integer from 1..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 of 1..15 without replacement until they reach a total >= 100.

Given an integer maxChoosableInteger and another integer desiredTotal, determine if the first player to move can force a win, assuming both players play optimally.

You can always assume that maxChoosableInteger will not be larger than 20 and desiredTotal will not be larger than 300.

Idea 1. DFS with memory.

Understanding the question is not easy, starting from small example,

maxChoosableInteger = 2, desiredTotoal = 3, first player lose, depends on who play the last, 2%2 = 0 means the 2nd player pick the last number

maxChoosableInteger = 2, desiredTotal = 4, first player lose no matter what number choose (or say both player will lose, as no one can reach the state to make the sum of choose numbers so far by both player  >= desiredTotal)

maxChoosableInteger = 2, desiredTotal = 2, if first player win if picking 2, otherwise lose

maxChoosableInteger = 3, desiredTotal = 5,

　　a. if 1st player choose 1, the state for second state is [2, 3], desiredTotoal = 4; if 2nd player choose 2, 1st player has state [3], desiredTotoal = 2, 1st player win; if 2nd player choose 3, 1st has tate [2], desiredTotal = 1, 1st player win; it mean no matter what 2nd palyer choose, with given state [2, 3], desiredTotal = 4, the 2nd player will lose, actually any player with such state will lose. As long as the 1st player can make a move and cause the state to be such losing state, the 1st player can win, or in any state which can make the next player lose, the current player can win.

b. if 1st player choose 2, the state is [1, 3], desiredTotal = 3; if 2nd player choose 3, the 2nd player win

c. if 1st player coose 3, the state is [1, 2], desiredTotal = 2; if the 2nd player choose 2, the 2nd player win.

Assume maxChoosableInteger = N for easy notation, result lose = false, win = true, considering the corner cases:

1. false if sum(1...N) = (1+N)*N/2 < desiredTotal

2. (N%2 == 1) if sum(1..N) == desiredTotal, depending who takes the last number

The core idea is to store the state and the result to save recomputation. If just bruteforce backtracking, the first player has N choices, the 2nd player has N-1 choices on the next level, there are N*(N-1)*(N-2)...1 = O(N!) nodes on searching tree,  since subproblems could get computed more than once, to avod recomputation on the same subproblem, a common technique is to use cache to store the state and result.  Since there are O(2^N) state, for each number can be picked or not, each subproblem takes O(N) time to loop the allowed number,

Time complexity: O(N2^N)

Space complexity: O(2^N)

How do we define the state of the game? Initially the list of allowed numbers + updated desired total, since the remaining total = desiredTotal - sum(not allowed number), the allowed numbers is enough to infer the remaining toal. How to represent the state?

1. arrays of integers [1...N] or arrays of boolean [true, true...]

2. integer, since N will not be larger than 20, we could use bit mask to represent the state by a number, for N = 2, 3(0b011) means 1 and 2 has been choosen. The advantage is that using integer do not need to reset the state after backtracking, as it's pass by value.

initial idea, arrays of integers + updated desired total for state, also the removing choosing elements from array is not a good idea, which is involved copying new array and inserting the element back to the original state to keep the order.

Note: we need to reset the state even it's winning, because we don't know which player is winning, we might need to continue searching, hence we need to reset the previous state before the current move.

 class Solution {
     private boolean canIWinHelper(int desiredTotal, List<Integer> candidates, Map<String, Boolean> gameCache) {
         String key = desiredTotal + ":" + candidates;
         if(gameCache.containsKey(key)) {
             return gameCache.get(key);
         }
         else {
             boolean result = false;

             List<Integer> copy = new ArrayList<>(candidates);
             for(int i= 0; i < copy.size(); ++i) {
                     int num = candidates.remove(i);
                     if(num >= desiredTotal || !canIWinHelper(desiredTotal - num, candidates, gameCache)) {
                         result = true;
                         candidates.add(i, num);
                         break;
                     }

                    candidates.add(i, num);
             }

             gameCache.put(key, result);
             return result;
         }
     }

     public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
         List<Integer> candidates = new ArrayList<>();
         int sum = 0;
         for(int i = 1; i <= maxChoosableInteger; ++i) {
             sum += i;
             candidates.add(i);
         }

         if(desiredTotal > sum) {
             return false;
         }

         Map<String, Boolean> gameCache = new HashMap<>();

         return canIWinHelper(desiredTotal, candidates, gameCache);
     }
 }

arrays of booleans with corner cases:

 class Solution {
     private boolean canIWinHelper(int desiredTotal, boolean[] state, Map<String, Boolean> gameCache) {
         String key = Arrays.toString(state);
         if(gameCache.containsKey(key)) {
             return gameCache.get(key);
         }

         boolean result = false;
         for(int i = 1; i <= state.length-1; ++i) {
             if(!state[i]) {
                 state[i] = true;
                 if(i >= desiredTotal || !canIWinHelper(desiredTotal - i, state, gameCache)) {
                     result = true;
                     state[i] = false;
                     break;
                 }
                 state[i] = false;
             }
         }
         gameCache.put(key, result);

         return result;
     }

     public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
          int sum = maxChoosableInteger * (1 + maxChoosableInteger);
          if(sum < desiredTotal) {
              return false;
          }
          if(sum == desiredTotal) {
              return (maxChoosableInteger%2 == 1);
          }

          boolean[] state = new boolean[maxChoosableInteger + 1];

         Map<String, Boolean> gameCache = new HashMap<>();

         return canIWinHelper(desiredTotal, state, gameCache);
     }
 }

integer as state, using bit operation

 class Solution {
     private boolean canIWinHelper(int maxChoosableInteger, int desiredTotal, int state, Map<Integer, Boolean> gameCache) {

         if(gameCache.containsKey(state)) {
             return gameCache.get(state);
         }

         boolean result = false;
         for(int i = 1; i <= maxChoosableInteger; ++i) {
             int allowed = (state >> i) & 1;
             if(allowed == 0) {
                 if(i >= desiredTotal || !canIWinHelper(maxChoosableInteger, desiredTotal - i, state^(1 << i), gameCache)) {
                     result = true;
                     break;
                 }
             }
         }
         gameCache.put(state, result);

         return result;
     }

     public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
          int sum = maxChoosableInteger * (1 + maxChoosableInteger);
          if(sum < desiredTotal) {
              return false;
          }
          if(sum == desiredTotal) {
              return (maxChoosableInteger%2 == 1);
          }

         Map<Integer, Boolean> gameCache = new HashMap<>();
         int state = 0;

         return canIWinHelper(maxChoosableInteger, desiredTotal, state, gameCache);
     }
 }

python much conciser code even using integer array

 class Solution:
     def canIWinHelper(self, candidates, desiredTotal, gameCache) -> bool:
         key = str(candidates)

         if key in gameCache:
             return gameCache[key]

         for i in range(len(candidates)):
             if candidates[i] >= desiredTotal or not self.canIWinHelper(list(candidates[:i]) + list(candidates[i+1:]), desiredTotal - candidates[i], gameCache):
                 gameCache[key] = True
                 return True

         gameCache[key] = False
         return False

     def canIWin(self, maxChoosableInteger: int, desiredTotal: int) -> bool:
         sum = maxChoosableInteger * (1 + maxChoosableInteger) / 2
         if sum < desiredTotal:
             return False

         if sum == desiredTotal:
             return (maxChoosableInteger%2 == 1)

         return self.canIWinHelper(range(1, maxChoosableInteger+1), desiredTotal, {})
         

 class Solution:
     def canIWinHelper(self, maxChoosableInteger, desiredTotal, state, gameCache) -> bool:
         if state in gameCache:
             return gameCache[state]

         for i in range(maxChoosableInteger):
             allowed = (state >> i) & 1
             if allowed == 0:
                 num = i + 1
                 if (num >= desiredTotal) or (not self.canIWinHelper(maxChoosableInteger, desiredTotal - num, state ^ (1 << i), gameCache)):
                     gameCache[state] = True
                     return True

         gameCache[state] = False
         return False

     def canIWin(self, maxChoosableInteger: int, desiredTotal: int) -> bool:
         sum = maxChoosableInteger * (1 + maxChoosableInteger) / 2
         if sum < desiredTotal:
             return False

         if sum == desiredTotal:
             return (maxChoosableInteger%2 == 1)

         return self.canIWinHelper(maxChoosableInteger, desiredTotal, 0, {})

Example

Input:
maxChoosableInteger = 10
desiredTotal = 11

Output:
false

Explanation:
No matter which integer the first player choose, the first player will lose.
The first player can choose an integer from 1 up to 10.
If the first player choose 1, the second player can only choose integers from 2 up to 10.
The second player will win by choosing 10 and get a total = 11, which is >= desiredTotal.
Same with other integers chosen by the first player, the second player will always win.