Skip to content

Commit 2e03b32

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1690
No.1690.Stone Game VII
1 parent 2d5a9db commit 2e03b32

File tree

6 files changed

+318
-2
lines changed

6 files changed

+318
-2
lines changed

‎solution/1600-1699/1690.Stone Game VII/README.md

+119-1
Original file line numberDiff line numberDiff line change
@@ -50,22 +50,140 @@
5050

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

53+
**方法一：记忆化搜索**
54+
55+
我们先预处理出前缀和数组 $s$，其中 $s[i]$ 表示前 $i$ 个石头的总和。
56+
57+
接下来，设计一个函数 $dfs(i, j)$，表示当剩下的石子为 $stones[i], stones[i + 1], \dots, stones[j]$ 时，先手与后手的得分差值。那么答案即为 $dfs(0, n - 1)$。
58+
59+
函数 $dfs(i, j)$ 的计算过程如下：
60+
61+
- 如果 $i \gt j$，说明当前没有石子，返回 $0$；
62+
- 否则，先手有两种选择，分别是移除 $stones[i]$ 或 $stones[j]$，然后计算得分差值，即 $a = s[j + 1] - s[i + 1] - dfs(i + 1, j)$ 和 $b = s[j] - s[i] - dfs(i, j - 1)$，我们取两者中的较大值作为 $dfs(i, j)$ 的返回值。
63+
64+
过程中，我们使用记忆化搜索，即使用数组 $f$ 记录函数 $dfs(i, j)$ 的返回值，避免重复计算。
65+
66+
时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 为石子的数量。
67+
5368
<!-- tabs:start -->
5469

5570
### **Python3**
5671

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

5974
```python
60-
75+
class Solution:
76+
def stoneGameVII(self, stones: List[int]) -> int:
77+
@cache
78+
def dfs(i, j):
79+
if i > j:
80+
return 0
81+
a = s[j + 1] - s[i + 1] - dfs(i + 1, j)
82+
b = s[j] - s[i] - dfs(i, j - 1)
83+
return max(a, b)
84+
85+
s = list(accumulate(stones, initial=0))
86+
ans = dfs(0, len(stones) - 1)
87+
dfs.cache_clear()
88+
return ans
6189
```
6290

6391
### **Java**
6492

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

6795
```java
96+
class Solution {
97+
private int[] s;
98+
private Integer[][] f;
99+
100+
public int stoneGameVII(int[] stones) {
101+
int n = stones.length;
102+
s = new int[n + 1];
103+
f = new Integer[n][n];
104+
for (int i = 0; i < n; ++i) {
105+
s[i + 1] = s[i] + stones[i];
106+
}
107+
return dfs(0, n - 1);
108+
}
109+
110+
private int dfs(int i, int j) {
111+
if (i > j) {
112+
return 0;
113+
}
114+
if (f[i][j] != null) {
115+
return f[i][j];
116+
}
117+
int a = s[j + 1] - s[i + 1] - dfs(i + 1, j);
118+
int b = s[j] - s[i] - dfs(i, j - 1);
119+
return f[i][j] = Math.max(a, b);
120+
}
121+
}
122+
```
123+
124+
### **C++**
125+
126+
```cpp
127+
class Solution {
128+
public:
129+
int stoneGameVII(vector<int>& stones) {
130+
int n = stones.size();
131+
int f[n][n];
132+
memset(f, 0, sizeof f);
133+
int s[n + 1];
134+
s[0] = 0;
135+
for (int i = 0; i < n; ++i) {
136+
s[i + 1] = s[i] + stones[i];
137+
}
138+
function<int(int, int)> dfs = [&](int i, int j) {
139+
if (i > j) {
140+
return 0;
141+
}
142+
if (f[i][j]) {
143+
return f[i][j];
144+
}
145+
int a = s[j + 1] - s[i + 1] - dfs(i + 1, j);
146+
int b = s[j] - s[i] - dfs(i, j - 1);
147+
return f[i][j] = max(a, b);
148+
};
149+
return dfs(0, n - 1);
150+
}
151+
};
152+
```
68153
154+
### **Go**
155+
156+
```go
157+
func stoneGameVII(stones []int) int {
158+
n := len(stones)
159+
s := make([]int, n+1)
160+
f := make([][]int, n)
161+
for i, x := range stones {
162+
s[i+1] = s[i] + x
163+
f[i] = make([]int, n)
164+
}
165+
var dfs func(int, int) int
166+
dfs = func(i, j int) int {
167+
if i > j {
168+
return 0
169+
}
170+
if f[i][j] != 0 {
171+
return f[i][j]
172+
}
173+
a := s[j+1] - s[i+1] - dfs(i+1, j)
174+
b := s[j] - s[i] - dfs(i, j-1)
175+
f[i][j] = max(a, b)
176+
return f[i][j]
177+
}
178+
return dfs(0, n-1)
179+
}
180+
181+
func max(a, b int) int {
182+
if a > b {
183+
return a
184+
}
185+
return b
186+
}
69187
```
70188

71189
### **...**

‎solution/1600-1699/1690.Stone Game VII/README_EN.md

+104-1
Original file line numberDiff line numberDiff line change
@@ -49,13 +49,116 @@ The score difference is 18 - 12 = 6.
4949
### **Python3**
5050

5151
```python
52-
52+
class Solution:
53+
def stoneGameVII(self, stones: List[int]) -> int:
54+
@cache
55+
def dfs(i, j):
56+
if i > j:
57+
return 0
58+
a = s[j + 1] - s[i + 1] - dfs(i + 1, j)
59+
b = s[j] - s[i] - dfs(i, j - 1)
60+
return max(a, b)
61+
62+
s = list(accumulate(stones, initial=0))
63+
ans = dfs(0, len(stones) - 1)
64+
dfs.cache_clear()
65+
return ans
5366
```
5467

5568
### **Java**
5669

5770
```java
71+
class Solution {
72+
private int[] s;
73+
private Integer[][] f;
74+
75+
public int stoneGameVII(int[] stones) {
76+
int n = stones.length;
77+
s = new int[n + 1];
78+
f = new Integer[n][n];
79+
for (int i = 0; i < n; ++i) {
80+
s[i + 1] = s[i] + stones[i];
81+
}
82+
return dfs(0, n - 1);
83+
}
84+
85+
private int dfs(int i, int j) {
86+
if (i > j) {
87+
return 0;
88+
}
89+
if (f[i][j] != null) {
90+
return f[i][j];
91+
}
92+
int a = s[j + 1] - s[i + 1] - dfs(i + 1, j);
93+
int b = s[j] - s[i] - dfs(i, j - 1);
94+
return f[i][j] = Math.max(a, b);
95+
}
96+
}
97+
```
98+
99+
### **C++**
100+
101+
```cpp
102+
class Solution {
103+
public:
104+
int stoneGameVII(vector<int>& stones) {
105+
int n = stones.size();
106+
int f[n][n];
107+
memset(f, 0, sizeof f);
108+
int s[n + 1];
109+
s[0] = 0;
110+
for (int i = 0; i < n; ++i) {
111+
s[i + 1] = s[i] + stones[i];
112+
}
113+
function<int(int, int)> dfs = [&](int i, int j) {
114+
if (i > j) {
115+
return 0;
116+
}
117+
if (f[i][j]) {
118+
return f[i][j];
119+
}
120+
int a = s[j + 1] - s[i + 1] - dfs(i + 1, j);
121+
int b = s[j] - s[i] - dfs(i, j - 1);
122+
return f[i][j] = max(a, b);
123+
};
124+
return dfs(0, n - 1);
125+
}
126+
};
127+
```
58128
129+
### **Go**
130+
131+
```go
132+
func stoneGameVII(stones []int) int {
133+
n := len(stones)
134+
s := make([]int, n+1)
135+
f := make([][]int, n)
136+
for i, x := range stones {
137+
s[i+1] = s[i] + x
138+
f[i] = make([]int, n)
139+
}
140+
var dfs func(int, int) int
141+
dfs = func(i, j int) int {
142+
if i > j {
143+
return 0
144+
}
145+
if f[i][j] != 0 {
146+
return f[i][j]
147+
}
148+
a := s[j+1] - s[i+1] - dfs(i+1, j)
149+
b := s[j] - s[i] - dfs(i, j-1)
150+
f[i][j] = max(a, b)
151+
return f[i][j]
152+
}
153+
return dfs(0, n-1)
154+
}
155+
156+
func max(a, b int) int {
157+
if a > b {
158+
return a
159+
}
160+
return b
161+
}
59162
```
60163

61164
### **...**

‎solution/1600-1699/1690.Stone Game VII/Solution.cpp

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public:
3+
int stoneGameVII(vector<int>& stones) {
4+
int n = stones.size();
5+
int f[n][n];
6+
memset(f, 0, sizeof f);
7+
int s[n + 1];
8+
s[0] = 0;
9+
for (int i = 0; i < n; ++i) {
10+
s[i + 1] = s[i] + stones[i];
11+
}
12+
function<int(int, int)> dfs = [&](int i, int j) {
13+
if (i > j) {
14+
return 0;
15+
}
16+
if (f[i][j]) {
17+
return f[i][j];
18+
}
19+
int a = s[j + 1] - s[i + 1] - dfs(i + 1, j);
20+
int b = s[j] - s[i] - dfs(i, j - 1);
21+
return f[i][j] = max(a, b);
22+
};
23+
return dfs(0, n - 1);
24+
}
25+
};

‎solution/1600-1699/1690.Stone Game VII/Solution.go

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
func stoneGameVII(stones []int) int {
2+
n := len(stones)
3+
s := make([]int, n+1)
4+
f := make([][]int, n)
5+
for i, x := range stones {
6+
s[i+1] = s[i] + x
7+
f[i] = make([]int, n)
8+
}
9+
var dfs func(int, int) int
10+
dfs = func(i, j int) int {
11+
if i > j {
12+
return 0
13+
}
14+
if f[i][j] != 0 {
15+
return f[i][j]
16+
}
17+
a := s[j+1] - s[i+1] - dfs(i+1, j)
18+
b := s[j] - s[i] - dfs(i, j-1)
19+
f[i][j] = max(a, b)
20+
return f[i][j]
21+
}
22+
return dfs(0, n-1)
23+
}
24+
25+
func max(a, b int) int {
26+
if a > b {
27+
return a
28+
}
29+
return b
30+
}

‎solution/1600-1699/1690.Stone Game VII/Solution.java

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
private int[] s;
3+
private Integer[][] f;
4+
5+
public int stoneGameVII(int[] stones) {
6+
int n = stones.length;
7+
s = new int[n + 1];
8+
f = new Integer[n][n];
9+
for (int i = 0; i < n; ++i) {
10+
s[i + 1] = s[i] + stones[i];
11+
}
12+
return dfs(0, n - 1);
13+
}
14+
15+
private int dfs(int i, int j) {
16+
if (i > j) {
17+
return 0;
18+
}
19+
if (f[i][j] != null) {
20+
return f[i][j];
21+
}
22+
int a = s[j + 1] - s[i + 1] - dfs(i + 1, j);
23+
int b = s[j] - s[i] - dfs(i, j - 1);
24+
return f[i][j] = Math.max(a, b);
25+
}
26+
}

‎solution/1600-1699/1690.Stone Game VII/Solution.py

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution:
2+
def stoneGameVII(self, stones: List[int]) -> int:
3+
@cache
4+
def dfs(i, j):
5+
if i > j:
6+
return 0
7+
a = s[j + 1] - s[i + 1] - dfs(i + 1, j)
8+
b = s[j] - s[i] - dfs(i, j - 1)
9+
return max(a, b)
10+
11+
s = list(accumulate(stones, initial=0))
12+
ans = dfs(0, len(stones) - 1)
13+
dfs.cache_clear()
14+
return ans

0 commit comments

Comments
 (0)