Skip to content

Commit bbd706d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1563
No.1563.Stone Game V
1 parent ea98d0c commit bbd706d

File tree

6 files changed

+517
-2
lines changed

6 files changed

+517
-2
lines changed

‎solution/1500-1599/1563.Stone Game V/README.md

+188-1
Original file line numberDiff line numberDiff line change
@@ -50,22 +50,209 @@
5050

5151
<!-- 这里可写通用的实现逻辑 -->
5252

53+
**方法一：记忆化搜索 + 剪枝**
54+
55+
我们先预处理出前缀和数组 $s$，其中 $s[i]$ 表示数组 $stoneValue$ 前 $i$ 个元素的和。
56+
57+
接下来，我们设计一个函数 $dfs(i, j)$，表示数组 $stoneValue$ 中下标范围 $[i, j]$ 内的石子，Alice 能够获得的最大分数。那么答案就是 $dfs(0, n - 1)$。
58+
59+
函数 $dfs(i, j)$ 的计算过程如下：
60+
61+
- 如果 $i = j$，说明只剩下一块石子，Alice 无法进行分割，因此返回 $0$。
62+
- 否则，我们枚举分割点 $k$，即 $i \leq k \lt j$，将数组 $stoneValue$ 中下标范围 $[i, j]$ 内的石子分割为 $[i, k]$ 和 $[k + 1, j]$ 两部分，计算出 $a$ 和 $b$，分别表示两部分的石子总和。然后我们分别计算 $dfs(i, k)$ 和 $dfs(k + 1, j)$，并更新答案。
63+
64+
注意，如果满足 $a \lt b$ 并且 $ans \geq a \times 2$，那么这一次枚举可以跳过；如果满足 $a \gt b$ 并且 $ans \geq b \times 2$，那么后续的枚举都可以跳过，直接退出循环。
65+
66+
最后，我们返回答案即可。
67+
68+
为了避免重复计算，我们可以使用记忆化搜索，同时使用剪枝优化枚举的效率。
69+
70+
时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为数组 $stoneValue$ 的长度。
71+
5372
<!-- tabs:start -->
5473

5574
### **Python3**
5675

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

5978
```python
60-
79+
class Solution:
80+
def stoneGameV(self, stoneValue: List[int]) -> int:
81+
@cache
82+
def dfs(i, j):
83+
if i == j:
84+
return 0
85+
ans = a = 0
86+
for k in range(i, j):
87+
a += stoneValue[k]
88+
b = s[j + 1] - s[i] - a
89+
if a < b:
90+
if ans >= a * 2:
91+
continue
92+
ans = max(ans, a + dfs(i, k))
93+
elif a > b:
94+
if ans >= b * 2:
95+
break
96+
ans = max(ans, b + dfs(k + 1, j))
97+
else:
98+
ans = max(ans, a + dfs(i, k), b + dfs(k + 1, j))
99+
return ans
100+
101+
s = list(accumulate(stoneValue, initial=0))
102+
return dfs(0, len(stoneValue) - 1)
61103
```
62104

63105
### **Java**
64106

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

67109
```java
110+
class Solution {
111+
private int n;
112+
private int[] s;
113+
private int[] stoneValue;
114+
private Integer[][] f;
115+
116+
public int stoneGameV(int[] stoneValue) {
117+
n = stoneValue.length;
118+
this.stoneValue = stoneValue;
119+
s = new int[n + 1];
120+
for (int i = 1; i <= n; ++i) {
121+
s[i] = s[i - 1] + stoneValue[i - 1];
122+
}
123+
f = new Integer[n][n];
124+
return dfs(0, n - 1);
125+
}
126+
127+
private int dfs(int i, int j) {
128+
if (i == j) {
129+
return 0;
130+
}
131+
if (f[i][j] != null) {
132+
return f[i][j];
133+
}
134+
int ans = 0;
135+
int a = 0;
136+
for (int k = i; k < j; ++k) {
137+
a += stoneValue[k];
138+
int b = s[j + 1] - s[i] - a;
139+
if (a < b) {
140+
if (ans >= a * 2) {
141+
continue;
142+
}
143+
ans = Math.max(ans, a + dfs(i, k));
144+
} else if (a > b) {
145+
if (ans >= b * 2) {
146+
break;
147+
}
148+
ans = Math.max(ans, b + dfs(k + 1, j));
149+
} else {
150+
ans = Math.max(ans, Math.max(a + dfs(i, k), b + dfs(k + 1, j)));
151+
}
152+
}
153+
return f[i][j] = ans;
154+
}
155+
}
156+
```
157+
158+
### **C++**
159+
160+
```cpp
161+
class Solution {
162+
public:
163+
int stoneGameV(vector<int>& stoneValue) {
164+
int n = stoneValue.size();
165+
int s[n + 1];
166+
s[0] = 0;
167+
for (int i = 1; i <= n; ++i) {
168+
s[i] = s[i - 1] + stoneValue[i - 1];
169+
}
170+
int f[n][n];
171+
memset(f, 0, sizeof(f));
172+
function<int(int, int)> dfs = [&](int i, int j) -> int {
173+
if (i == j) {
174+
return 0;
175+
}
176+
if (f[i][j]) {
177+
return f[i][j];
178+
}
179+
int ans = 0;
180+
int a = 0;
181+
for (int k = i; k < j; ++k) {
182+
a += stoneValue[k];
183+
int b = s[j + 1] - s[i] - a;
184+
if (a < b) {
185+
if (ans >= a * 2) {
186+
continue;
187+
}
188+
ans = max(ans, a + dfs(i, k));
189+
} else if (a > b) {
190+
if (ans >= b * 2) {
191+
break;
192+
}
193+
ans = max(ans, b + dfs(k + 1, j));
194+
} else {
195+
ans = max({ans, a + dfs(i, k), b + dfs(k + 1, j)});
196+
}
197+
}
198+
return f[i][j] = ans;
199+
};
200+
return dfs(0, n - 1);
201+
}
202+
};
203+
```
68204
205+
### **Go**
206+
207+
```go
208+
func stoneGameV(stoneValue []int) int {
209+
n := len(stoneValue)
210+
s := make([]int, n+1)
211+
for i, x := range stoneValue {
212+
s[i+1] = s[i] + x
213+
}
214+
f := make([][]int, n)
215+
for i := range f {
216+
f[i] = make([]int, n)
217+
}
218+
var dfs func(i, j int) int
219+
dfs = func(i, j int) int {
220+
if i == j {
221+
return 0
222+
}
223+
if f[i][j] != 0 {
224+
return f[i][j]
225+
}
226+
ans, a := 0, 0
227+
for k := i; k < j; k++ {
228+
a += stoneValue[k]
229+
b := s[j+1] - s[i] - a
230+
if a < b {
231+
if ans >= a*2 {
232+
continue
233+
}
234+
ans = max(ans, a+dfs(i, k))
235+
} else if a > b {
236+
if ans >= b*2 {
237+
break
238+
}
239+
ans = max(ans, b+dfs(k+1, j))
240+
} else {
241+
ans = max(ans, max(a+dfs(i, k), b+dfs(k+1, j)))
242+
}
243+
}
244+
f[i][j] = ans
245+
return ans
246+
}
247+
return dfs(0, n-1)
248+
}
249+
250+
func max(a, b int) int {
251+
if a > b {
252+
return a
253+
}
254+
return b
255+
}
69256
```
70257

71258
### **...**

‎solution/1500-1599/1563.Stone Game V/README_EN.md

+169-1
Original file line numberDiff line numberDiff line change
@@ -52,13 +52,181 @@ The last round Alice has only one choice to divide the row which is [2], [3]. Bo
5252
### **Python3**
5353

5454
```python
55-
55+
class Solution:
56+
def stoneGameV(self, stoneValue: List[int]) -> int:
57+
@cache
58+
def dfs(i, j):
59+
if i == j:
60+
return 0
61+
ans = a = 0
62+
for k in range(i, j):
63+
a += stoneValue[k]
64+
b = s[j + 1] - s[i] - a
65+
if a < b:
66+
if ans >= a * 2:
67+
continue
68+
ans = max(ans, a + dfs(i, k))
69+
elif a > b:
70+
if ans >= b * 2:
71+
break
72+
ans = max(ans, b + dfs(k + 1, j))
73+
else:
74+
ans = max(ans, a + dfs(i, k), b + dfs(k + 1, j))
75+
return ans
76+
77+
s = list(accumulate(stoneValue, initial=0))
78+
return dfs(0, len(stoneValue) - 1)
5679
```
5780

5881
### **Java**
5982

6083
```java
84+
class Solution {
85+
private int n;
86+
private int[] s;
87+
private int[] stoneValue;
88+
private Integer[][] f;
89+
90+
public int stoneGameV(int[] stoneValue) {
91+
n = stoneValue.length;
92+
this.stoneValue = stoneValue;
93+
s = new int[n + 1];
94+
for (int i = 1; i <= n; ++i) {
95+
s[i] = s[i - 1] + stoneValue[i - 1];
96+
}
97+
f = new Integer[n][n];
98+
return dfs(0, n - 1);
99+
}
100+
101+
private int dfs(int i, int j) {
102+
if (i == j) {
103+
return 0;
104+
}
105+
if (f[i][j] != null) {
106+
return f[i][j];
107+
}
108+
int ans = 0;
109+
int a = 0;
110+
for (int k = i; k < j; ++k) {
111+
a += stoneValue[k];
112+
int b = s[j + 1] - s[i] - a;
113+
if (a < b) {
114+
if (ans >= a * 2) {
115+
continue;
116+
}
117+
ans = Math.max(ans, a + dfs(i, k));
118+
} else if (a > b) {
119+
if (ans >= b * 2) {
120+
break;
121+
}
122+
ans = Math.max(ans, b + dfs(k + 1, j));
123+
} else {
124+
ans = Math.max(ans, Math.max(a + dfs(i, k), b + dfs(k + 1, j)));
125+
}
126+
}
127+
return f[i][j] = ans;
128+
}
129+
}
130+
```
131+
132+
### **C++**
133+
134+
```cpp
135+
class Solution {
136+
public:
137+
int stoneGameV(vector<int>& stoneValue) {
138+
int n = stoneValue.size();
139+
int s[n + 1];
140+
s[0] = 0;
141+
for (int i = 1; i <= n; ++i) {
142+
s[i] = s[i - 1] + stoneValue[i - 1];
143+
}
144+
int f[n][n];
145+
memset(f, 0, sizeof(f));
146+
function<int(int, int)> dfs = [&](int i, int j) -> int {
147+
if (i == j) {
148+
return 0;
149+
}
150+
if (f[i][j]) {
151+
return f[i][j];
152+
}
153+
int ans = 0;
154+
int a = 0;
155+
for (int k = i; k < j; ++k) {
156+
a += stoneValue[k];
157+
int b = s[j + 1] - s[i] - a;
158+
if (a < b) {
159+
if (ans >= a * 2) {
160+
continue;
161+
}
162+
ans = max(ans, a + dfs(i, k));
163+
} else if (a > b) {
164+
if (ans >= b * 2) {
165+
break;
166+
}
167+
ans = max(ans, b + dfs(k + 1, j));
168+
} else {
169+
ans = max({ans, a + dfs(i, k), b + dfs(k + 1, j)});
170+
}
171+
}
172+
return f[i][j] = ans;
173+
};
174+
return dfs(0, n - 1);
175+
}
176+
};
177+
```
61178
179+
### **Go**
180+
181+
```go
182+
func stoneGameV(stoneValue []int) int {
183+
n := len(stoneValue)
184+
s := make([]int, n+1)
185+
for i, x := range stoneValue {
186+
s[i+1] = s[i] + x
187+
}
188+
f := make([][]int, n)
189+
for i := range f {
190+
f[i] = make([]int, n)
191+
}
192+
var dfs func(i, j int) int
193+
dfs = func(i, j int) int {
194+
if i == j {
195+
return 0
196+
}
197+
if f[i][j] != 0 {
198+
return f[i][j]
199+
}
200+
ans, a := 0, 0
201+
for k := i; k < j; k++ {
202+
a += stoneValue[k]
203+
b := s[j+1] - s[i] - a
204+
if a < b {
205+
if ans >= a*2 {
206+
continue
207+
}
208+
ans = max(ans, a+dfs(i, k))
209+
} else if a > b {
210+
if ans >= b*2 {
211+
break
212+
}
213+
ans = max(ans, b+dfs(k+1, j))
214+
} else {
215+
ans = max(ans, max(a+dfs(i, k), b+dfs(k+1, j)))
216+
}
217+
}
218+
f[i][j] = ans
219+
return ans
220+
}
221+
return dfs(0, n-1)
222+
}
223+
224+
func max(a, b int) int {
225+
if a > b {
226+
return a
227+
}
228+
return b
229+
}
62230
```
63231

64232
### **...**

0 commit comments

Comments
 (0)