Skip to content

Commit 54b5eab

Browse files
yanglbmeyanglbme
committedDec 20, 2022
feat: add solutions to lc problem: No.1770
No.1770.Maximum Score from Performing Multiplication Operations
1 parent c531be3 commit 54b5eab

File tree

6 files changed

+307
-2
lines changed

6 files changed

+307
-2
lines changed
 

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

+114-1
Original file line numberDiff line numberDiff line change
@@ -59,22 +59,135 @@
5959

6060
<!-- 这里可写通用的实现逻辑 -->
6161

62+
**方法一：记忆化搜索**
63+
64+
我们设计一个函数 $dfs(i, j)$，表示从 `nums` 数组头部第 $i$ 个元素开始，从 `nums` 数组尾部第 $j$ 个元素开始，能够获得的最大分数。那么答案就是 $dfs(0, 0)$。
65+
66+
函数 $dfs(i, j)$ 的计算过程如下：
67+
68+
- 如果 $i \geq m$ 或者 $j \geq m$，或者 $i + j \geq m$，说明已经没有元素可以选择了，返回 $0$。
69+
- 否则，我们可以选择 `nums` 数组头部第 $i$ 个元素，那么能够获取的最大分数为 $nums[i] \times multipliers[i + j] + dfs(i + 1, j)$；或者我们可以选择 `nums` 数组尾部第 $j$ 个元素，那么能够获取的最大分数为 $nums[n - j - 1] \times multipliers[i + j] + dfs(i, j + 1)$。我们取两者的最大值作为 $dfs(i, j)$ 的返回值。
70+
71+
我们可以使用记忆化搜索来实现上述递归过程，其中 `f` 数组用于存储函数 $dfs(i, j)$ 的返回值，防止重复计算。
72+
73+
时间复杂度 $O(m^2)$，空间复杂度 $O(m^2)$。其中 $m$ 为 `multipliers` 数组的长度。
74+
6275
<!-- tabs:start -->
6376

6477
### **Python3**
6578

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

6881
```python
69-
82+
class Solution:
83+
def maximumScore(self, nums: List[int], multipliers: List[int]) -> int:
84+
@cache
85+
def f(i, j, k):
86+
if k >= m or i >= n or j < 0:
87+
return 0
88+
a = f(i + 1, j, k + 1) + nums[i] * multipliers[k]
89+
b = f(i, j - 1, k + 1) + nums[j] * multipliers[k]
90+
return max(a, b)
91+
92+
n = len(nums)
93+
m = len(multipliers)
94+
return f(0, n - 1, 0)
7095
```
7196

7297
### **Java**
7398

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

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

80193
### **...**

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

+101-1
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,113 @@ The total score is 50 + 15 - 9 + 4 + 42 = 102.
6464
### **Python3**
6565

6666
```python
67-
67+
class Solution:
68+
def maximumScore(self, nums: List[int], multipliers: List[int]) -> int:
69+
@cache
70+
def f(i, j, k):
71+
if k >= m or i >= n or j < 0:
72+
return 0
73+
a = f(i + 1, j, k + 1) + nums[i] * multipliers[k]
74+
b = f(i, j - 1, k + 1) + nums[j] * multipliers[k]
75+
return max(a, b)
76+
77+
n = len(nums)
78+
m = len(multipliers)
79+
return f(0, n - 1, 0)
6880
```
6981

7082
### **Java**
7183

7284
```java
85+
class Solution {
86+
private Integer[][] f;
87+
private int[] multipliers;
88+
private int[] nums;
89+
private int n;
90+
private int m;
91+
92+
public int maximumScore(int[] nums, int[] multipliers) {
93+
n = nums.length;
94+
m = multipliers.length;
95+
f = new Integer[m][m];
96+
this.nums = nums;
97+
this.multipliers = multipliers;
98+
return dfs(0, 0);
99+
}
100+
101+
private int dfs(int i, int j) {
102+
if (i >= m || j >= m || (i + j) >= m) {
103+
return 0;
104+
}
105+
if (f[i][j] != null) {
106+
return f[i][j];
107+
}
108+
int k = i + j;
109+
int a = dfs(i + 1, j) + nums[i] * multipliers[k];
110+
int b = dfs(i, j + 1) + nums[n - 1 - j] * multipliers[k];
111+
f[i][j] = Math.max(a, b);
112+
return f[i][j];
113+
}
114+
}
115+
```
116+
117+
### **C++**
118+
119+
```cpp
120+
class Solution {
121+
public:
122+
int maximumScore(vector<int>& nums, vector<int>& multipliers) {
123+
int n = nums.size(), m = multipliers.size();
124+
int f[m][m];
125+
memset(f, 0x3f, sizeof f);
126+
function<int(int, int)> dfs = [&](int i, int j) -> int {
127+
if (i >= m || j >= m || (i + j) >= m) return 0;
128+
if (f[i][j] != 0x3f3f3f3f) return f[i][j];
129+
int k = i + j;
130+
int a = dfs(i + 1, j) + nums[i] * multipliers[k];
131+
int b = dfs(i, j + 1) + nums[n - j - 1] * multipliers[k];
132+
return f[i][j] = max(a, b);
133+
};
134+
return dfs(0, 0);
135+
}
136+
};
137+
```
73138
139+
### **Go**
140+
141+
```go
142+
func maximumScore(nums []int, multipliers []int) int {
143+
n, m := len(nums), len(multipliers)
144+
f := make([][]int, m)
145+
for i := range f {
146+
f[i] = make([]int, m)
147+
for j := range f[i] {
148+
f[i][j] = 1 << 30
149+
}
150+
}
151+
var dfs func(i, j int) int
152+
dfs = func(i, j int) int {
153+
if i >= m || j >= m || i+j >= m {
154+
return 0
155+
}
156+
if f[i][j] != 1<<30 {
157+
return f[i][j]
158+
}
159+
k := i + j
160+
a := dfs(i+1, j) + nums[i]*multipliers[k]
161+
b := dfs(i, j+1) + nums[n-j-1]*multipliers[k]
162+
f[i][j] = max(a, b)
163+
return f[i][j]
164+
}
165+
return dfs(0, 0)
166+
}
167+
168+
func max(a, b int) int {
169+
if a > b {
170+
return a
171+
}
172+
return b
173+
}
74174
```
75175

76176
### **...**

‎solution/1700-1799/1770.Maximum Score from Performing Multiplication Operations/Solution.cpp

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution {
2+
public:
3+
int maximumScore(vector<int>& nums, vector<int>& multipliers) {
4+
int n = nums.size(), m = multipliers.size();
5+
int f[m][m];
6+
memset(f, 0x3f, sizeof f);
7+
function<int(int, int)> dfs = [&](int i, int j) -> int {
8+
if (i >= m || j >= m || (i + j) >= m) return 0;
9+
if (f[i][j] != 0x3f3f3f3f) return f[i][j];
10+
int k = i + j;
11+
int a = dfs(i + 1, j) + nums[i] * multipliers[k];
12+
int b = dfs(i, j + 1) + nums[n - j - 1] * multipliers[k];
13+
return f[i][j] = max(a, b);
14+
};
15+
return dfs(0, 0);
16+
}
17+
};

‎solution/1700-1799/1770.Maximum Score from Performing Multiplication Operations/Solution.go

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

‎solution/1700-1799/1770.Maximum Score from Performing Multiplication Operations/Solution.java

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
private Integer[][] f;
3+
private int[] multipliers;
4+
private int[] nums;
5+
private int n;
6+
private int m;
7+
8+
public int maximumScore(int[] nums, int[] multipliers) {
9+
n = nums.length;
10+
m = multipliers.length;
11+
f = new Integer[m][m];
12+
this.nums = nums;
13+
this.multipliers = multipliers;
14+
return dfs(0, 0);
15+
}
16+
17+
private int dfs(int i, int j) {
18+
if (i >= m || j >= m || (i + j) >= m) {
19+
return 0;
20+
}
21+
if (f[i][j] != null) {
22+
return f[i][j];
23+
}
24+
int k = i + j;
25+
int a = dfs(i + 1, j) + nums[i] * multipliers[k];
26+
int b = dfs(i, j + 1) + nums[n - 1 - j] * multipliers[k];
27+
f[i][j] = Math.max(a, b);
28+
return f[i][j];
29+
}
30+
}

‎solution/1700-1799/1770.Maximum Score from Performing Multiplication Operations/Solution.py

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
class Solution:
2+
def maximumScore(self, nums: List[int], multipliers: List[int]) -> int:
3+
@cache
4+
def f(i, j, k):
5+
if k >= m or i >= n or j < 0:
6+
return 0
7+
a = f(i + 1, j, k + 1) + nums[i] * multipliers[k]
8+
b = f(i, j - 1, k + 1) + nums[j] * multipliers[k]
9+
return max(a, b)
10+
11+
n = len(nums)
12+
m = len(multipliers)
13+
return f(0, n - 1, 0)

0 commit comments

Comments
 (0)