Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit ccc354f

Browse files
feat: add solutions to lc problem: No.1458 (doocs#3354)
No.1458.Max Dot Product of Two Subsequences
1 parent 3b44422 commit ccc354f

File tree

8 files changed

+177
-124
lines changed

8 files changed

+177
-124
lines changed

‎solution/1400-1499/1458.Max Dot Product of Two Subsequences/README.md

Lines changed: 60 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -80,17 +80,16 @@ tags:
8080

8181
### 方法一:动态规划
8282

83-
定义 $dp[i][j]$ 表示 $nums1$ 前 $i$ 个元素和 $nums2$ 前 $j$ 个元素得到的最大点积。
83+
我们定义 $f[i][j]$ 表示 $\textit{nums1}$ 的前 $i$ 个元素和 $\textit{nums2}$ 的前 $j$ 个元素构成的两个子序列的最大点积。初始时 $f[i][j] = -\infty$。
8484

85-
那么有:
85+
对于 $f[i][j],ドル我们有以下几种情况:
8686

87-
$$
88-
dp[i][j]=max(dp[i-1][j], dp[i][j - 1], max(dp[i - 1][j - 1], 0) + nums1[i] \times nums2[j])
89-
$$
87+
1. 不选 $\textit{nums1}[i-1]$ 或者不选 $\textit{nums2}[j-1],ドル即 $f[i][j] = \max(f[i-1][j], f[i][j-1])$;
88+
2. 选 $\textit{nums1}[i-1]$ 和 $\textit{nums2}[j-1],ドル即 $f[i][j] = \max(f[i][j], \max(0, f[i-1][j-1]) + \textit{nums1}[i-1] \times \textit{nums2}[j-1])$。
9089

91-
答案为 $dp[m][n]$。
90+
最终答案即为 $f[m][n]$。
9291

93-
时间复杂度 $O(m \times n),ドル空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是数组 $nums1$ 和 $nums2$ 的长度。
92+
时间复杂度 $O(m \times n),ドル空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是数组 $\textit{nums1}$ 和 $\textit{nums2}$ 的长度。
9493

9594
<!-- tabs:start -->
9695

@@ -100,12 +99,12 @@ $$
10099
class Solution:
101100
def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:
102101
m, n = len(nums1), len(nums2)
103-
dp = [[-inf] * (n + 1) for _ in range(m + 1)]
104-
for iin range(1, m + 1):
105-
for jin range(1, n + 1):
106-
v = nums1[i -1] * nums2[j -1]
107-
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], max(dp[i - 1][j - 1], 0) + v)
108-
return dp[-1][-1]
102+
f = [[-inf] * (n + 1) for _ in range(m + 1)]
103+
for i, x in enumerate(nums1, 1):
104+
for j, y in enumerate(nums2, 1):
105+
v = x * y
106+
f[i][j] = max(f[i - 1][j], f[i][j - 1], max(0, f[i - 1][j - 1]) + v)
107+
return f[m][n]
109108
```
110109

111110
#### Java
@@ -114,18 +113,18 @@ class Solution:
114113
class Solution {
115114
public int maxDotProduct(int[] nums1, int[] nums2) {
116115
int m = nums1.length, n = nums2.length;
117-
int[][] dp = new int[m + 1][n + 1];
118-
for (int[] e : dp) {
119-
Arrays.fill(e, Integer.MIN_VALUE);
116+
int[][] f = new int[m + 1][n + 1];
117+
for (var g : f) {
118+
Arrays.fill(g, Integer.MIN_VALUE);
120119
}
121120
for (int i = 1; i <= m; ++i) {
122121
for (int j = 1; j <= n; ++j) {
123-
dp[i][j] =Math.max(dp[i - 1][j], dp[i][j - 1]);
124-
dp[i][j] = Math.max(
125-
dp[i][j], Math.max(0, dp[i -1][j-1]) + nums1[i - 1]* nums2[j - 1]);
122+
int v = nums1[i - 1]* nums2[j - 1];
123+
f[i][j] = Math.max(f[i -1][j], f[i][j -1]);
124+
f[i][j]=Math.max(f[i][j], Math.max(f[i - 1][j - 1], 0) + v);
126125
}
127126
}
128-
return dp[m][n];
127+
return f[m][n];
129128
}
130129
}
131130
```
@@ -137,15 +136,16 @@ class Solution {
137136
public:
138137
int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
139138
int m = nums1.size(), n = nums2.size();
140-
vector<vector<int>> dp(m + 1, vector<int>(n + 1, INT_MIN));
139+
int f[m + 1][n + 1];
140+
memset(f, 0xc0, sizeof f);
141141
for (int i = 1; i <= m; ++i) {
142142
for (int j = 1; j <= n; ++j) {
143143
int v = nums1[i - 1] * nums2[j - 1];
144-
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
145-
dp[i][j] = max(dp[i][j], max(0, dp[i - 1][j - 1]) + v);
144+
f[i][j] = max(f[i - 1][j], f[i][j - 1]);
145+
f[i][j] = max(f[i][j], max(0, f[i - 1][j - 1]) + v);
146146
}
147147
}
148-
return dp[m][n];
148+
return f[m][n];
149149
}
150150
};
151151
```
@@ -155,45 +155,60 @@ public:
155155
```go
156156
func maxDotProduct(nums1 []int, nums2 []int) int {
157157
m, n := len(nums1), len(nums2)
158-
dp := make([][]int, m+1)
159-
for i := range dp {
160-
dp[i] = make([]int, n+1)
161-
for j := range dp[i] {
162-
dp[i][j] = math.MinInt32
158+
f := make([][]int, m+1)
159+
for i := range f {
160+
f[i] = make([]int, n+1)
161+
for j := range f[i] {
162+
f[i][j] = math.MinInt32
163163
}
164164
}
165165
for i := 1; i <= m; i++ {
166166
for j := 1; j <= n; j++ {
167167
v := nums1[i-1] * nums2[j-1]
168-
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
169-
dp[i][j] = max(dp[i][j], max(0, dp[i-1][j-1])+v)
168+
f[i][j] = max(f[i-1][j], f[i][j-1])
169+
f[i][j] = max(f[i][j], max(0, f[i-1][j-1])+v)
170170
}
171171
}
172-
return dp[m][n]
172+
return f[m][n]
173+
}
174+
```
175+
176+
#### TypeScript
177+
178+
```ts
179+
function maxDotProduct(nums1: number[], nums2: number[]): number {
180+
const m = nums1.length;
181+
const n = nums2.length;
182+
const f = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => -Infinity));
183+
for (let i = 1; i <= m; ++i) {
184+
for (let j = 1; j <= n; ++j) {
185+
const v = nums1[i - 1] * nums2[j - 1];
186+
f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
187+
f[i][j] = Math.max(f[i][j], Math.max(0, f[i - 1][j - 1]) + v);
188+
}
189+
}
190+
return f[m][n];
173191
}
174192
```
175193

176194
#### Rust
177195

178196
```rust
179197
impl Solution {
180-
#[allow(dead_code)]
181198
pub fn max_dot_product(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
182-
let n = nums1.len();
183-
let m = nums2.len();
184-
let mut dp = vec![vec![i32::MIN; m + 1]; n + 1];
185-
186-
// Begin the actual dp process
187-
for i in 1..=n {
188-
for j in 1..=m {
189-
dp[i][j] = std::cmp::max(
190-
std::cmp::max(dp[i - 1][j], dp[i][j - 1]),
191-
std::cmp::max(dp[i - 1][j - 1], 0) + nums1[i - 1] * nums2[j - 1],
192-
);
199+
let m = nums1.len();
200+
let n = nums2.len();
201+
let mut f = vec![vec![i32::MIN; n + 1]; m + 1];
202+
203+
for i in 1..=m {
204+
for j in 1..=n {
205+
let v = nums1[i - 1] * nums2[j - 1];
206+
f[i][j] = f[i][j].max(f[i - 1][j]).max(f[i][j - 1]);
207+
f[i][j] = f[i][j].max(f[i - 1][j - 1].max(0) + v);
193208
}
194209
}
195210

196-
dp[n][m]
211+
f[m][n]
197212
}
198213
}
199214
```

‎solution/1400-1499/1458.Max Dot Product of Two Subsequences/README_EN.md

Lines changed: 66 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,18 @@ Their dot product is -1.</pre>
6464

6565
<!-- solution:start -->
6666

67-
### Solution 1
67+
### Solution 1: Dynamic Programming
68+
69+
We define $f[i][j]$ to represent the maximum dot product of two subsequences formed by the first $i$ elements of $\textit{nums1}$ and the first $j$ elements of $\textit{nums2}$. Initially, $f[i][j] = -\infty$.
70+
71+
For $f[i][j],ドル we have the following cases:
72+
73+
1. Do not select $\textit{nums1}[i-1]$ or do not select $\textit{nums2}[j-1],ドル i.e., $f[i][j] = \max(f[i-1][j], f[i][j-1])$;
74+
2. Select $\textit{nums1}[i-1]$ and $\textit{nums2}[j-1],ドル i.e., $f[i][j] = \max(f[i][j], \max(0, f[i-1][j-1]) + \textit{nums1}[i-1] \times \textit{nums2}[j-1])$.
75+
76+
The final answer is $f[m][n]$.
77+
78+
The time complexity is $O(m \times n),ドル and the space complexity is $O(m \times n)$. Here, $m$ and $n$ are the lengths of the arrays $\textit{nums1}$ and $\textit{nums2},ドル respectively.
6879

6980
<!-- tabs:start -->
7081

@@ -74,12 +85,12 @@ Their dot product is -1.</pre>
7485
class Solution:
7586
def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:
7687
m, n = len(nums1), len(nums2)
77-
dp = [[-inf] * (n + 1) for _ in range(m + 1)]
78-
for iin range(1, m + 1):
79-
for jin range(1, n + 1):
80-
v = nums1[i -1] * nums2[j -1]
81-
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1], max(dp[i - 1][j - 1], 0) + v)
82-
return dp[-1][-1]
88+
f = [[-inf] * (n + 1) for _ in range(m + 1)]
89+
for i, x in enumerate(nums1, 1):
90+
for j, y in enumerate(nums2, 1):
91+
v = x * y
92+
f[i][j] = max(f[i - 1][j], f[i][j - 1], max(0, f[i - 1][j - 1]) + v)
93+
return f[m][n]
8394
```
8495

8596
#### Java
@@ -88,18 +99,18 @@ class Solution:
8899
class Solution {
89100
public int maxDotProduct(int[] nums1, int[] nums2) {
90101
int m = nums1.length, n = nums2.length;
91-
int[][] dp = new int[m + 1][n + 1];
92-
for (int[] e : dp) {
93-
Arrays.fill(e, Integer.MIN_VALUE);
102+
int[][] f = new int[m + 1][n + 1];
103+
for (var g : f) {
104+
Arrays.fill(g, Integer.MIN_VALUE);
94105
}
95106
for (int i = 1; i <= m; ++i) {
96107
for (int j = 1; j <= n; ++j) {
97-
dp[i][j] =Math.max(dp[i - 1][j], dp[i][j - 1]);
98-
dp[i][j] = Math.max(
99-
dp[i][j], Math.max(0, dp[i -1][j-1]) + nums1[i - 1]* nums2[j - 1]);
108+
int v = nums1[i - 1]* nums2[j - 1];
109+
f[i][j] = Math.max(f[i -1][j], f[i][j -1]);
110+
f[i][j]=Math.max(f[i][j], Math.max(f[i - 1][j - 1], 0) + v);
100111
}
101112
}
102-
return dp[m][n];
113+
return f[m][n];
103114
}
104115
}
105116
```
@@ -111,15 +122,16 @@ class Solution {
111122
public:
112123
int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
113124
int m = nums1.size(), n = nums2.size();
114-
vector<vector<int>> dp(m + 1, vector<int>(n + 1, INT_MIN));
125+
int f[m + 1][n + 1];
126+
memset(f, 0xc0, sizeof f);
115127
for (int i = 1; i <= m; ++i) {
116128
for (int j = 1; j <= n; ++j) {
117129
int v = nums1[i - 1] * nums2[j - 1];
118-
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
119-
dp[i][j] = max(dp[i][j], max(0, dp[i - 1][j - 1]) + v);
130+
f[i][j] = max(f[i - 1][j], f[i][j - 1]);
131+
f[i][j] = max(f[i][j], max(0, f[i - 1][j - 1]) + v);
120132
}
121133
}
122-
return dp[m][n];
134+
return f[m][n];
123135
}
124136
};
125137
```
@@ -129,45 +141,60 @@ public:
129141
```go
130142
func maxDotProduct(nums1 []int, nums2 []int) int {
131143
m, n := len(nums1), len(nums2)
132-
dp := make([][]int, m+1)
133-
for i := range dp {
134-
dp[i] = make([]int, n+1)
135-
for j := range dp[i] {
136-
dp[i][j] = math.MinInt32
144+
f := make([][]int, m+1)
145+
for i := range f {
146+
f[i] = make([]int, n+1)
147+
for j := range f[i] {
148+
f[i][j] = math.MinInt32
137149
}
138150
}
139151
for i := 1; i <= m; i++ {
140152
for j := 1; j <= n; j++ {
141153
v := nums1[i-1] * nums2[j-1]
142-
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
143-
dp[i][j] = max(dp[i][j], max(0, dp[i-1][j-1])+v)
154+
f[i][j] = max(f[i-1][j], f[i][j-1])
155+
f[i][j] = max(f[i][j], max(0, f[i-1][j-1])+v)
144156
}
145157
}
146-
return dp[m][n]
158+
return f[m][n]
159+
}
160+
```
161+
162+
#### TypeScript
163+
164+
```ts
165+
function maxDotProduct(nums1: number[], nums2: number[]): number {
166+
const m = nums1.length;
167+
const n = nums2.length;
168+
const f = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => -Infinity));
169+
for (let i = 1; i <= m; ++i) {
170+
for (let j = 1; j <= n; ++j) {
171+
const v = nums1[i - 1] * nums2[j - 1];
172+
f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
173+
f[i][j] = Math.max(f[i][j], Math.max(0, f[i - 1][j - 1]) + v);
174+
}
175+
}
176+
return f[m][n];
147177
}
148178
```
149179

150180
#### Rust
151181

152182
```rust
153183
impl Solution {
154-
#[allow(dead_code)]
155184
pub fn max_dot_product(nums1: Vec<i32>, nums2: Vec<i32>) -> i32 {
156-
let n = nums1.len();
157-
let m = nums2.len();
158-
let mut dp = vec![vec![i32::MIN; m + 1]; n + 1];
159-
160-
// Begin the actual dp process
161-
for i in 1..=n {
162-
for j in 1..=m {
163-
dp[i][j] = std::cmp::max(
164-
std::cmp::max(dp[i - 1][j], dp[i][j - 1]),
165-
std::cmp::max(dp[i - 1][j - 1], 0) + nums1[i - 1] * nums2[j - 1],
166-
);
185+
let m = nums1.len();
186+
let n = nums2.len();
187+
let mut f = vec![vec![i32::MIN; n + 1]; m + 1];
188+
189+
for i in 1..=m {
190+
for j in 1..=n {
191+
let v = nums1[i - 1] * nums2[j - 1];
192+
f[i][j] = f[i][j].max(f[i - 1][j]).max(f[i][j - 1]);
193+
f[i][j] = f[i][j].max(f[i - 1][j - 1].max(0) + v);
167194
}
168195
}
169196

170-
dp[n][m]
197+
f[m][n]
171198
}
172199
}
173200
```

‎solution/1400-1499/1458.Max Dot Product of Two Subsequences/Solution.cpp

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -2,14 +2,15 @@ class Solution {
22
public:
33
int maxDotProduct(vector<int>& nums1, vector<int>& nums2) {
44
int m = nums1.size(), n = nums2.size();
5-
vector<vector<int>> dp(m + 1, vector<int>(n + 1, INT_MIN));
5+
int f[m + 1][n + 1];
6+
memset(f, 0xc0, sizeof f);
67
for (int i = 1; i <= m; ++i) {
78
for (int j = 1; j <= n; ++j) {
89
int v = nums1[i - 1] * nums2[j - 1];
9-
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
10-
dp[i][j] = max(dp[i][j], max(0, dp[i - 1][j - 1]) + v);
10+
f[i][j] = max(f[i - 1][j], f[i][j - 1]);
11+
f[i][j] = max(f[i][j], max(0, f[i - 1][j - 1]) + v);
1112
}
1213
}
13-
return dp[m][n];
14+
return f[m][n];
1415
}
15-
};
16+
};
Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,18 @@
11
func maxDotProduct(nums1 []int, nums2 []int) int {
22
m, n := len(nums1), len(nums2)
3-
dp := make([][]int, m+1)
4-
for i := range dp {
5-
dp[i] = make([]int, n+1)
6-
for j := range dp[i] {
7-
dp[i][j] = math.MinInt32
3+
f := make([][]int, m+1)
4+
for i := range f {
5+
f[i] = make([]int, n+1)
6+
for j := range f[i] {
7+
f[i][j] = math.MinInt32
88
}
99
}
1010
for i := 1; i <= m; i++ {
1111
for j := 1; j <= n; j++ {
1212
v := nums1[i-1] * nums2[j-1]
13-
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
14-
dp[i][j] = max(dp[i][j], max(0, dp[i-1][j-1])+v)
13+
f[i][j] = max(f[i-1][j], f[i][j-1])
14+
f[i][j] = max(f[i][j], max(0, f[i-1][j-1])+v)
1515
}
1616
}
17-
return dp[m][n]
18-
}
17+
return f[m][n]
18+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /