Skip to content

Commit 461eeb7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0464
No.0464.Can I Win
1 parent 3f7932f commit 461eeb7

File tree

6 files changed

+302
-2
lines changed

6 files changed

+302
-2
lines changed

‎solution/0400-0499/0464.Can I Win/README.md

+105-1
Original file line numberDiff line numberDiff line change
@@ -56,22 +56,126 @@
5656

5757
<!-- 这里可写通用的实现逻辑 -->
5858

59+
**方法一：状态压缩 + 记忆化搜索**
60+
5961
<!-- tabs:start -->
6062

6163
### **Python3**
6264

6365
<!-- 这里可写当前语言的特殊实现逻辑 -->
6466

6567
```python
66-
68+
class Solution:
69+
def canIWin(self, maxChoosableInteger: int, desiredTotal: int) -> bool:
70+
@lru_cache(None)
71+
def dfs(state, t):
72+
for i in range(1, maxChoosableInteger + 1):
73+
if (state >> i) & 1:
74+
continue
75+
if t + i >= desiredTotal or not dfs(state | 1 << i, t + i):
76+
return True
77+
return False
78+
79+
s = (1 + maxChoosableInteger) * maxChoosableInteger // 2
80+
if s < desiredTotal:
81+
return False
82+
return dfs(0, 0)
6783
```
6884

6985
### **Java**
7086

7187
<!-- 这里可写当前语言的特殊实现逻辑 -->
7288

7389
```java
90+
class Solution {
91+
private Map<Integer, Boolean> memo = new HashMap<>();
92+
93+
public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
94+
int s = (1 + maxChoosableInteger) * maxChoosableInteger / 2;
95+
if (s < desiredTotal) {
96+
return false;
97+
}
98+
return dfs(0, 0, maxChoosableInteger, desiredTotal);
99+
}
100+
101+
private boolean dfs(int state, int t, int maxChoosableInteger, int desiredTotal) {
102+
if (memo.containsKey(state)) {
103+
return memo.get(state);
104+
}
105+
boolean res = false;
106+
for (int i = 1; i <= maxChoosableInteger; ++i) {
107+
if (((state >> i) & 1) == 0) {
108+
if (t + i >= desiredTotal || !dfs(state | 1 << i, t + i, maxChoosableInteger, desiredTotal)) {
109+
res = true;
110+
break;
111+
}
112+
}
113+
}
114+
memo.put(state, res);
115+
return res;
116+
}
117+
}
118+
```
119+
120+
### **C++**
121+
122+
```cpp
123+
class Solution {
124+
public:
125+
bool canIWin(int maxChoosableInteger, int desiredTotal) {
126+
int s = (1 + maxChoosableInteger) * maxChoosableInteger / 2;
127+
if (s < desiredTotal) return false;
128+
unordered_map<int, bool> memo;
129+
return dfs(0, 0, maxChoosableInteger, desiredTotal, memo);
130+
}
131+
132+
bool dfs(int state, int t, int maxChoosableInteger, int desiredTotal, unordered_map<int, bool>& memo) {
133+
if (memo.count(state)) return memo[state];
134+
bool res = false;
135+
for (int i = 1; i <= maxChoosableInteger; ++i)
136+
{
137+
if ((state >> i) & 1) continue;
138+
if (t + i >= desiredTotal || !dfs(state | 1 << i, t + i, maxChoosableInteger, desiredTotal, memo))
139+
{
140+
res = true;
141+
break;
142+
}
143+
}
144+
memo[state] = res;
145+
return res;
146+
}
147+
};
148+
```
74149

150+
### **Go**
151+
152+
```go
153+
func canIWin(maxChoosableInteger int, desiredTotal int) bool {
154+
s := (1 + maxChoosableInteger) * maxChoosableInteger / 2
155+
if s < desiredTotal {
156+
return false
157+
}
158+
memo := map[int]bool{}
159+
var dfs func(int, int) bool
160+
dfs = func(state, t int) bool {
161+
if v, ok := memo[state]; ok {
162+
return v
163+
}
164+
res := false
165+
for i := 1; i <= maxChoosableInteger; i++ {
166+
if (state>>i)&1 == 1 {
167+
continue
168+
}
169+
if t+i >= desiredTotal || !dfs(state|1<<i, t+i) {
170+
res = true
171+
break
172+
}
173+
}
174+
memo[state] = res
175+
return res
176+
}
177+
return dfs(0, 0)
178+
}
75179
```
76180

77181
### **...**

‎solution/0400-0499/0464.Can I Win/README_EN.md

+103-1
Original file line numberDiff line numberDiff line change
@@ -55,13 +55,115 @@ Same with other integers chosen by the first player, the second player will alwa
5555
### **Python3**
5656

5757
```python
58-
58+
class Solution:
59+
def canIWin(self, maxChoosableInteger: int, desiredTotal: int) -> bool:
60+
@lru_cache(None)
61+
def dfs(state, t):
62+
for i in range(1, maxChoosableInteger + 1):
63+
if (state >> i) & 1:
64+
continue
65+
if t + i >= desiredTotal or not dfs(state | 1 << i, t + i):
66+
return True
67+
return False
68+
69+
s = (1 + maxChoosableInteger) * maxChoosableInteger // 2
70+
if s < desiredTotal:
71+
return False
72+
return dfs(0, 0)
5973
```
6074

6175
### **Java**
6276

6377
```java
78+
class Solution {
79+
private Map<Integer, Boolean> memo = new HashMap<>();
80+
81+
public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
82+
int s = (1 + maxChoosableInteger) * maxChoosableInteger / 2;
83+
if (s < desiredTotal) {
84+
return false;
85+
}
86+
return dfs(0, 0, maxChoosableInteger, desiredTotal);
87+
}
88+
89+
private boolean dfs(int state, int t, int maxChoosableInteger, int desiredTotal) {
90+
if (memo.containsKey(state)) {
91+
return memo.get(state);
92+
}
93+
boolean res = false;
94+
for (int i = 1; i <= maxChoosableInteger; ++i) {
95+
if (((state >> i) & 1) == 0) {
96+
if (t + i >= desiredTotal || !dfs(state | 1 << i, t + i, maxChoosableInteger, desiredTotal)) {
97+
res = true;
98+
break;
99+
}
100+
}
101+
}
102+
memo.put(state, res);
103+
return res;
104+
}
105+
}
106+
```
107+
108+
### **C++**
109+
110+
```cpp
111+
class Solution {
112+
public:
113+
bool canIWin(int maxChoosableInteger, int desiredTotal) {
114+
int s = (1 + maxChoosableInteger) * maxChoosableInteger / 2;
115+
if (s < desiredTotal) return false;
116+
unordered_map<int, bool> memo;
117+
return dfs(0, 0, maxChoosableInteger, desiredTotal, memo);
118+
}
119+
120+
bool dfs(int state, int t, int maxChoosableInteger, int desiredTotal, unordered_map<int, bool>& memo) {
121+
if (memo.count(state)) return memo[state];
122+
bool res = false;
123+
for (int i = 1; i <= maxChoosableInteger; ++i)
124+
{
125+
if ((state >> i) & 1) continue;
126+
if (t + i >= desiredTotal || !dfs(state | 1 << i, t + i, maxChoosableInteger, desiredTotal, memo))
127+
{
128+
res = true;
129+
break;
130+
}
131+
}
132+
memo[state] = res;
133+
return res;
134+
}
135+
};
136+
```
64137

138+
### **Go**
139+
140+
```go
141+
func canIWin(maxChoosableInteger int, desiredTotal int) bool {
142+
s := (1 + maxChoosableInteger) * maxChoosableInteger / 2
143+
if s < desiredTotal {
144+
return false
145+
}
146+
memo := map[int]bool{}
147+
var dfs func(int, int) bool
148+
dfs = func(state, t int) bool {
149+
if v, ok := memo[state]; ok {
150+
return v
151+
}
152+
res := false
153+
for i := 1; i <= maxChoosableInteger; i++ {
154+
if (state>>i)&1 == 1 {
155+
continue
156+
}
157+
if t+i >= desiredTotal || !dfs(state|1<<i, t+i) {
158+
res = true
159+
break
160+
}
161+
}
162+
memo[state] = res
163+
return res
164+
}
165+
return dfs(0, 0)
166+
}
65167
```
66168

67169
### **...**

‎solution/0400-0499/0464.Can I Win/Solution.cpp

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
bool canIWin(int maxChoosableInteger, int desiredTotal) {
4+
int s = (1 + maxChoosableInteger) * maxChoosableInteger / 2;
5+
if (s < desiredTotal) return false;
6+
unordered_map<int, bool> memo;
7+
return dfs(0, 0, maxChoosableInteger, desiredTotal, memo);
8+
}
9+
10+
bool dfs(int state, int t, int maxChoosableInteger, int desiredTotal, unordered_map<int, bool>& memo) {
11+
if (memo.count(state)) return memo[state];
12+
bool res = false;
13+
for (int i = 1; i <= maxChoosableInteger; ++i)
14+
{
15+
if ((state >> i) & 1) continue;
16+
if (t + i >= desiredTotal || !dfs(state | 1 << i, t + i, maxChoosableInteger, desiredTotal, memo))
17+
{
18+
res = true;
19+
break;
20+
}
21+
}
22+
memo[state] = res;
23+
return res;
24+
}
25+
};

‎solution/0400-0499/0464.Can I Win/Solution.go

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
func canIWin(maxChoosableInteger int, desiredTotal int) bool {
2+
s := (1 + maxChoosableInteger) * maxChoosableInteger / 2
3+
if s < desiredTotal {
4+
return false
5+
}
6+
memo := map[int]bool{}
7+
var dfs func(int, int) bool
8+
dfs = func(state, t int) bool {
9+
if v, ok := memo[state]; ok {
10+
return v
11+
}
12+
res := false
13+
for i := 1; i <= maxChoosableInteger; i++ {
14+
if (state>>i)&1 == 1 {
15+
continue
16+
}
17+
if t+i >= desiredTotal || !dfs(state|1<<i, t+i) {
18+
res = true
19+
break
20+
}
21+
}
22+
memo[state] = res
23+
return res
24+
}
25+
return dfs(0, 0)
26+
}

‎solution/0400-0499/0464.Can I Win/Solution.java

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
private Map<Integer, Boolean> memo = new HashMap<>();
3+
4+
public boolean canIWin(int maxChoosableInteger, int desiredTotal) {
5+
int s = (1 + maxChoosableInteger) * maxChoosableInteger / 2;
6+
if (s < desiredTotal) {
7+
return false;
8+
}
9+
return dfs(0, 0, maxChoosableInteger, desiredTotal);
10+
}
11+
12+
private boolean dfs(int state, int t, int maxChoosableInteger, int desiredTotal) {
13+
if (memo.containsKey(state)) {
14+
return memo.get(state);
15+
}
16+
boolean res = false;
17+
for (int i = 1; i <= maxChoosableInteger; ++i) {
18+
if (((state >> i) & 1) == 0) {
19+
if (t + i >= desiredTotal || !dfs(state | 1 << i, t + i, maxChoosableInteger, desiredTotal)) {
20+
res = true;
21+
break;
22+
}
23+
}
24+
}
25+
memo.put(state, res);
26+
return res;
27+
}
28+
}

‎solution/0400-0499/0464.Can I Win/Solution.py

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution:
2+
def canIWin(self, maxChoosableInteger: int, desiredTotal: int) -> bool:
3+
@lru_cache(None)
4+
def dfs(state, t):
5+
for i in range(1, maxChoosableInteger + 1):
6+
if (state >> i) & 1:
7+
continue
8+
if t + i >= desiredTotal or not dfs(state | 1 << i, t + i):
9+
return True
10+
return False
11+
12+
s = (1 + maxChoosableInteger) * maxChoosableInteger // 2
13+
if s < desiredTotal:
14+
return False
15+
return dfs(0, 0)

0 commit comments

Comments
 (0)