Skip to content

Commit 3d33259

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1770
No.1770.Maximum Score from Performing Multiplication Operations
1 parent ea043a1 commit 3d33259

File tree

9 files changed

+416
-65
lines changed

9 files changed

+416
-65
lines changed

‎solution/0000-0099/0057.Insert Interval/Solution.py

+3-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
class Solution:
2-
def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
2+
def insert(
3+
self, intervals: List[List[int]], newInterval: List[int]
4+
) -> List[List[int]]:
35
st, ed = newInterval
46
ans = []
57
insert = False

‎solution/0100-0199/0155.Min Stack/Solution.py

-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
11
class MinStack:
2-
32
def __init__(self):
43
self.stk1 = []
54
self.stk2 = [inf]

‎solution/1700-1799/1770.Maximum Score from Performing Multiplication Operations/README.md

+161
Original file line numberDiff line numberDiff line change
@@ -72,6 +72,18 @@
7272

7373
时间复杂度 $O(m^2)$，空间复杂度 $O(m^2)$。其中 $m$ 为 `multipliers` 数组的长度。
7474

75+
**方法二：动态规划**
76+
77+
我们可以将方法一中的记忆化搜索改写为动态规划的形式。
78+
79+
我们用 $f[i][j]$ 表示取数组 $nums$ 的前 $i$ 个元素，以及取数组 $nums$ 的后 $j$ 个元素，能够获得的最大分数。初始时 $f[0][0] = 0$，其余元素均为 $-\infty$。答案为 $\max_{0 \leq i \leq m} f[i][m-i]$。
80+
81+
考虑 $f[i][j]$，那么当前我们可以选择 `nums` 数组头部的第 $i$ 个元素，或者选择 `nums` 数组尾部的第 $j$ 个元素。如果选择了 `nums` 数组头部的第 $i$ 个元素，那么能够获得的最大分数为 $f[i-1][j] + nums[i-1] \times multipliers[i+j-1]$；如果选择了 `nums` 数组尾部的第 $j$ 个元素，那么能够获得的最大分数为 $f[i][j-1] + nums[n-j] \times multipliers[i+j-1]$。我们取两者的最大值作为 $f[i][j]$ 的值。如果 $i + j = m$，我们我们更新答案 $ans = \max(ans, f[i][j])$。
82+
83+
最后返回答案 $ans$ 即可。
84+
85+
时间复杂度 $O(m^2)$，空间复杂度 $O(m^2)$。其中 $m$ 为 `multipliers` 数组的长度。
86+
7587
<!-- tabs:start -->
7688

7789
### **Python3**
@@ -94,6 +106,25 @@ class Solution:
94106
return f(0, n - 1, 0)
95107
```
96108

109+
```python
110+
class Solution:
111+
def maximumScore(self, nums: List[int], multipliers: List[int]) -> int:
112+
n, m = len(nums), len(multipliers)
113+
f = [[-inf] * (m + 1) for _ in range(m + 1)]
114+
f[0][0] = 0
115+
ans = -inf
116+
for i in range(m + 1):
117+
for j in range(m - i + 1):
118+
k = i + j - 1
119+
if i > 0:
120+
f[i][j] = max(f[i][j], f[i - 1][j] + multipliers[k] * nums[i - 1])
121+
if j > 0:
122+
f[i][j] = max(f[i][j], f[i][j - 1] + multipliers[k] * nums[n - j])
123+
if i + j == m:
124+
ans = max(ans, f[i][j])
125+
return ans
126+
```
127+
97128
### **Java**
98129

99130
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -131,6 +162,36 @@ class Solution {
131162
}
132163
```
133164

165+
```java
166+
class Solution {
167+
public int maximumScore(int[] nums, int[] multipliers) {
168+
final int inf = 1 << 30;
169+
int n = nums.length, m = multipliers.length;
170+
int[][] f = new int[m + 1][m + 1];
171+
for (int i = 0; i <= m; i++) {
172+
Arrays.fill(f[i], -inf);
173+
}
174+
f[0][0] = 0;
175+
int ans = -inf;
176+
for (int i = 0; i <= m; ++i) {
177+
for (int j = 0; j <= m - i; ++j) {
178+
int k = i + j - 1;
179+
if (i > 0) {
180+
f[i][j] = Math.max(f[i][j], f[i - 1][j] + multipliers[k] * nums[i - 1]);
181+
}
182+
if (j > 0) {
183+
f[i][j] = Math.max(f[i][j], f[i][j - 1] + multipliers[k] * nums[n - j]);
184+
}
185+
if (i + j == m) {
186+
ans = Math.max(ans, f[i][j]);
187+
}
188+
}
189+
}
190+
return ans;
191+
}
192+
}
193+
```
194+
134195
### **C++**
135196

136197
```cpp
@@ -153,6 +214,34 @@ public:
153214
};
154215
```
155216
217+
```cpp
218+
class Solution {
219+
public:
220+
int maximumScore(vector<int>& nums, vector<int>& multipliers) {
221+
const int inf = 1 << 30;
222+
int n = nums.size(), m = multipliers.size();
223+
vector<vector<int>> f(m + 1, vector<int>(m + 1, -inf));
224+
f[0][0] = 0;
225+
int ans = -inf;
226+
for (int i = 0; i <= m; ++i) {
227+
for (int j = 0; j <= m - i; ++j) {
228+
int k = i + j - 1;
229+
if (i > 0) {
230+
f[i][j] = max(f[i][j], f[i - 1][j] + multipliers[k] * nums[i - 1]);
231+
}
232+
if (j > 0) {
233+
f[i][j] = max(f[i][j], f[i][j - 1] + multipliers[k] * nums[n - j]);
234+
}
235+
if (i + j == m) {
236+
ans = max(ans, f[i][j]);
237+
}
238+
}
239+
}
240+
return ans;
241+
}
242+
};
243+
```
244+
156245
### **Go**
157246

158247
```go
@@ -190,6 +279,78 @@ func max(a, b int) int {
190279
}
191280
```
192281

282+
```go
283+
func maximumScore(nums []int, multipliers []int) int {
284+
const inf int = 1 << 30
285+
n, m := len(nums), len(multipliers)
286+
f := make([][]int, m+1)
287+
for i := range f {
288+
f[i] = make([]int, m+1)
289+
for j := range f {
290+
f[i][j] = -inf
291+
}
292+
}
293+
f[0][0] = 0
294+
ans := -inf
295+
for i := 0; i <= m; i++ {
296+
for j := 0; j <= m-i; j++ {
297+
k := i + j - 1
298+
if i > 0 {
299+
f[i][j] = max(f[i][j], f[i-1][j]+multipliers[k]*nums[i-1])
300+
}
301+
if j > 0 {
302+
f[i][j] = max(f[i][j], f[i][j-1]+multipliers[k]*nums[n-j])
303+
}
304+
if i+j == m {
305+
ans = max(ans, f[i][j])
306+
}
307+
}
308+
}
309+
return ans
310+
}
311+
312+
func max(a, b int) int {
313+
if a > b {
314+
return a
315+
}
316+
return b
317+
}
318+
```
319+
320+
### **TypeScript**
321+
322+
```ts
323+
function maximumScore(nums: number[], multipliers: number[]): number {
324+
const inf = 1 << 30;
325+
const n = nums.length;
326+
const m = multipliers.length;
327+
const f = new Array(m + 1).fill(0).map(() => new Array(m + 1).fill(-inf));
328+
f[0][0] = 0;
329+
let ans = -inf;
330+
for (let i = 0; i <= m; ++i) {
331+
for (let j = 0; j <= m - i; ++j) {
332+
const k = i + j - 1;
333+
if (i > 0) {
334+
f[i][j] = Math.max(
335+
f[i][j],
336+
f[i - 1][j] + nums[i - 1] * multipliers[k],
337+
);
338+
}
339+
if (j > 0) {
340+
f[i][j] = Math.max(
341+
f[i][j],
342+
f[i][j - 1] + nums[n - j] * multipliers[k],
343+
);
344+
}
345+
if (i + j === m) {
346+
ans = Math.max(ans, f[i][j]);
347+
}
348+
}
349+
}
350+
return ans;
351+
}
352+
```
353+
193354
### **...**
194355

195356
```

‎solution/1700-1799/1770.Maximum Score from Performing Multiplication Operations/README_EN.md

+149
Original file line numberDiff line numberDiff line change
@@ -79,6 +79,25 @@ class Solution:
7979
return f(0, n - 1, 0)
8080
```
8181

82+
```python
83+
class Solution:
84+
def maximumScore(self, nums: List[int], multipliers: List[int]) -> int:
85+
n, m = len(nums), len(multipliers)
86+
f = [[-inf] * (m + 1) for _ in range(m + 1)]
87+
f[0][0] = 0
88+
ans = -inf
89+
for i in range(m + 1):
90+
for j in range(m - i + 1):
91+
k = i + j - 1
92+
if i > 0:
93+
f[i][j] = max(f[i][j], f[i - 1][j] + multipliers[k] * nums[i - 1])
94+
if j > 0:
95+
f[i][j] = max(f[i][j], f[i][j - 1] + multipliers[k] * nums[n - j])
96+
if i + j == m:
97+
ans = max(ans, f[i][j])
98+
return ans
99+
```
100+
82101
### **Java**
83102

84103
```java
@@ -114,6 +133,36 @@ class Solution {
114133
}
115134
```
116135

136+
```java
137+
class Solution {
138+
public int maximumScore(int[] nums, int[] multipliers) {
139+
final int inf = 1 << 30;
140+
int n = nums.length, m = multipliers.length;
141+
int[][] f = new int[m + 1][m + 1];
142+
for (int i = 0; i <= m; i++) {
143+
Arrays.fill(f[i], -inf);
144+
}
145+
f[0][0] = 0;
146+
int ans = -inf;
147+
for (int i = 0; i <= m; ++i) {
148+
for (int j = 0; j <= m - i; ++j) {
149+
int k = i + j - 1;
150+
if (i > 0) {
151+
f[i][j] = Math.max(f[i][j], f[i - 1][j] + multipliers[k] * nums[i - 1]);
152+
}
153+
if (j > 0) {
154+
f[i][j] = Math.max(f[i][j], f[i][j - 1] + multipliers[k] * nums[n - j]);
155+
}
156+
if (i + j == m) {
157+
ans = Math.max(ans, f[i][j]);
158+
}
159+
}
160+
}
161+
return ans;
162+
}
163+
}
164+
```
165+
117166
### **C++**
118167

119168
```cpp
@@ -136,6 +185,34 @@ public:
136185
};
137186
```
138187
188+
```cpp
189+
class Solution {
190+
public:
191+
int maximumScore(vector<int>& nums, vector<int>& multipliers) {
192+
const int inf = 1 << 30;
193+
int n = nums.size(), m = multipliers.size();
194+
vector<vector<int>> f(m + 1, vector<int>(m + 1, -inf));
195+
f[0][0] = 0;
196+
int ans = -inf;
197+
for (int i = 0; i <= m; ++i) {
198+
for (int j = 0; j <= m - i; ++j) {
199+
int k = i + j - 1;
200+
if (i > 0) {
201+
f[i][j] = max(f[i][j], f[i - 1][j] + multipliers[k] * nums[i - 1]);
202+
}
203+
if (j > 0) {
204+
f[i][j] = max(f[i][j], f[i][j - 1] + multipliers[k] * nums[n - j]);
205+
}
206+
if (i + j == m) {
207+
ans = max(ans, f[i][j]);
208+
}
209+
}
210+
}
211+
return ans;
212+
}
213+
};
214+
```
215+
139216
### **Go**
140217

141218
```go
@@ -173,6 +250,78 @@ func max(a, b int) int {
173250
}
174251
```
175252

253+
```go
254+
func maximumScore(nums []int, multipliers []int) int {
255+
const inf int = 1 << 30
256+
n, m := len(nums), len(multipliers)
257+
f := make([][]int, m+1)
258+
for i := range f {
259+
f[i] = make([]int, m+1)
260+
for j := range f {
261+
f[i][j] = -inf
262+
}
263+
}
264+
f[0][0] = 0
265+
ans := -inf
266+
for i := 0; i <= m; i++ {
267+
for j := 0; j <= m-i; j++ {
268+
k := i + j - 1
269+
if i > 0 {
270+
f[i][j] = max(f[i][j], f[i-1][j]+multipliers[k]*nums[i-1])
271+
}
272+
if j > 0 {
273+
f[i][j] = max(f[i][j], f[i][j-1]+multipliers[k]*nums[n-j])
274+
}
275+
if i+j == m {
276+
ans = max(ans, f[i][j])
277+
}
278+
}
279+
}
280+
return ans
281+
}
282+
283+
func max(a, b int) int {
284+
if a > b {
285+
return a
286+
}
287+
return b
288+
}
289+
```
290+
291+
### **TypeScript**
292+
293+
```ts
294+
function maximumScore(nums: number[], multipliers: number[]): number {
295+
const inf = 1 << 30;
296+
const n = nums.length;
297+
const m = multipliers.length;
298+
const f = new Array(m + 1).fill(0).map(() => new Array(m + 1).fill(-inf));
299+
f[0][0] = 0;
300+
let ans = -inf;
301+
for (let i = 0; i <= m; ++i) {
302+
for (let j = 0; j <= m - i; ++j) {
303+
const k = i + j - 1;
304+
if (i > 0) {
305+
f[i][j] = Math.max(
306+
f[i][j],
307+
f[i - 1][j] + nums[i - 1] * multipliers[k],
308+
);
309+
}
310+
if (j > 0) {
311+
f[i][j] = Math.max(
312+
f[i][j],
313+
f[i][j - 1] + nums[n - j] * multipliers[k],
314+
);
315+
}
316+
if (i + j === m) {
317+
ans = Math.max(ans, f[i][j]);
318+
}
319+
}
320+
}
321+
return ans;
322+
}
323+
```
324+
176325
### **...**
177326

178327
```

0 commit comments

Comments
 (0)