-
Notifications
You must be signed in to change notification settings - Fork 83
/
CanIWin464.java
99 lines (89 loc) · 3.31 KB
/
CanIWin464.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/**
* 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.
*
* 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.
*/
public class CanIWin464 {
public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
if (desiredTotal == 0) return true;
if (((1 + maxChoosableInteger) / 2 * maxChoosableInteger) < desiredTotal) {
return false;
}
return helper(new boolean[maxChoosableInteger], desiredTotal, new HashMap<>());
}
private boolean helper(boolean[] set, int desiredTotal, Map<String, Boolean> memo) {
if (desiredTotal <= 0) return false;
String k = setKey(set);
if (memo.containsKey(k)) return memo.get(k);
for (int i=set.length-1; i>=0; i--) {
if (!set[i]) {
set[i] = true;
if (!helper(set, desiredTotal-i-1, memo)) {
set[i] = false;
memo.put(k, true);
return true;
}
set[i] = false;
}
}
memo.put(k, false);
return false;
}
private String setKey(boolean[] set) {
StringBuilder sb = new StringBuilder();
for (boolean b: set) {
sb.append(b ? 't' : 'f');
}
return sb.toString();
}
public boolean canIWin2(int maxChoosableInteger, int desiredTotal) {
if (desiredTotal == 0) return true;
if (((1 + maxChoosableInteger) / 2 * maxChoosableInteger) < desiredTotal) {
return false;
}
return helper(0, desiredTotal, new Boolean[1 << maxChoosableInteger], maxChoosableInteger);
}
private boolean helper(int state, int desiredTotal, Boolean[] memo, int M) {
if (desiredTotal <= 0) return false;
if (memo[state] != null) return memo[state];
for (int i=M-1; i>=0; i--) {
if ((state & (1 << i)) == 0) {
state |= 1 << i;
if (!helper(state, desiredTotal-i-1, memo, M)) {
state &= ~(1 << i);
memo[state] = true;
return true;
}
state &= ~(1 << i);
}
}
memo[state] = false;
return false;
}
}