Skip to content

Commit 60a3cc5

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3411 (doocs#3927)
No.3411.Maximum Subarray With Equal Products
1 parent 17f24f0 commit 60a3cc5

File tree

6 files changed

+366
-8
lines changed

6 files changed

+366
-8
lines changed

‎solution/3400-3499/3411.Maximum Subarray With Equal Products/README.md

+122-4
Original file line numberDiff line numberDiff line change
@@ -88,25 +88,143 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3411.Ma
8888
#### Python3
8989

9090
```python
91-
91+
class Solution:
92+
def maxLength(self, nums: List[int]) -> int:
93+
n = len(nums)
94+
ans = 0
95+
max_p = lcm(*nums) * max(nums)
96+
for i in range(n):
97+
p, g, l = 1, 0, 1
98+
for j in range(i, n):
99+
p *= nums[j]
100+
g = gcd(g, nums[j])
101+
l = lcm(l, nums[j])
102+
if p == g * l:
103+
ans = max(ans, j - i + 1)
104+
if p > max_p:
105+
break
106+
return ans
92107
```
93108

94109
#### Java
95110

96111
```java
97-
112+
class Solution {
113+
public int maxLength(int[] nums) {
114+
int mx = 0, ml = 1;
115+
for (int x : nums) {
116+
mx = Math.max(mx, x);
117+
ml = lcm(ml, x);
118+
}
119+
int maxP = ml * mx;
120+
int n = nums.length;
121+
int ans = 0;
122+
for (int i = 0; i < n; ++i) {
123+
int p = 1, g = 0, l = 1;
124+
for (int j = i; j < n; ++j) {
125+
p *= nums[j];
126+
g = gcd(g, nums[j]);
127+
l = lcm(l, nums[j]);
128+
if (p == g * l) {
129+
ans = Math.max(ans, j - i + 1);
130+
}
131+
if (p > maxP) {
132+
break;
133+
}
134+
}
135+
}
136+
return ans;
137+
}
138+
139+
private int gcd(int a, int b) {
140+
while (b != 0) {
141+
int temp = b;
142+
b = a % b;
143+
a = temp;
144+
}
145+
return a;
146+
}
147+
148+
private int lcm(int a, int b) {
149+
return a / gcd(a, b) * b;
150+
}
151+
}
98152
```
99153

100154
#### C++
101155

102156
```cpp
103-
157+
class Solution {
158+
public:
159+
int maxLength(vector<int>& nums) {
160+
int mx = 0, ml = 1;
161+
for (int x : nums) {
162+
mx = max(mx, x);
163+
ml = lcm(ml, x);
164+
}
165+
166+
long long maxP = (long long) ml * mx;
167+
int n = nums.size();
168+
int ans = 0;
169+
for (int i = 0; i < n; ++i) {
170+
long long p = 1, g = 0, l = 1;
171+
for (int j = i; j < n; ++j) {
172+
p *= nums[j];
173+
g = gcd(g, nums[j]);
174+
l = lcm(l, nums[j]);
175+
176+
if (p == g * l) {
177+
ans = max(ans, j - i + 1);
178+
}
179+
if (p > maxP) {
180+
break;
181+
}
182+
}
183+
}
184+
return ans;
185+
}
186+
};
104187
```
105188

106189
#### Go
107190

108191
```go
109-
192+
func maxLength(nums []int) int {
193+
mx, ml := 0, 1
194+
for _, x := range nums {
195+
mx = max(mx, x)
196+
ml = lcm(ml, x)
197+
}
198+
maxP := ml * mx
199+
n := len(nums)
200+
ans := 0
201+
for i := 0; i < n; i++ {
202+
p, g, l := 1, 0, 1
203+
for j := i; j < n; j++ {
204+
p *= nums[j]
205+
g = gcd(g, nums[j])
206+
l = lcm(l, nums[j])
207+
if p == g*l {
208+
ans = max(ans, j-i+1)
209+
}
210+
if p > maxP {
211+
break
212+
}
213+
}
214+
}
215+
return ans
216+
}
217+
218+
func gcd(a, b int) int {
219+
for b != 0 {
220+
a, b = b, a%b
221+
}
222+
return a
223+
}
224+
225+
func lcm(a, b int) int {
226+
return a / gcd(a, b) * b
227+
}
110228
```
111229

112230
<!-- tabs:end -->

‎solution/3400-3499/3411.Maximum Subarray With Equal Products/README_EN.md

+122-4
Original file line numberDiff line numberDiff line change
@@ -86,25 +86,143 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3411.Ma
8686
#### Python3
8787

8888
```python
89-
89+
class Solution:
90+
def maxLength(self, nums: List[int]) -> int:
91+
n = len(nums)
92+
ans = 0
93+
max_p = lcm(*nums) * max(nums)
94+
for i in range(n):
95+
p, g, l = 1, 0, 1
96+
for j in range(i, n):
97+
p *= nums[j]
98+
g = gcd(g, nums[j])
99+
l = lcm(l, nums[j])
100+
if p == g * l:
101+
ans = max(ans, j - i + 1)
102+
if p > max_p:
103+
break
104+
return ans
90105
```
91106

92107
#### Java
93108

94109
```java
95-
110+
class Solution {
111+
public int maxLength(int[] nums) {
112+
int mx = 0, ml = 1;
113+
for (int x : nums) {
114+
mx = Math.max(mx, x);
115+
ml = lcm(ml, x);
116+
}
117+
int maxP = ml * mx;
118+
int n = nums.length;
119+
int ans = 0;
120+
for (int i = 0; i < n; ++i) {
121+
int p = 1, g = 0, l = 1;
122+
for (int j = i; j < n; ++j) {
123+
p *= nums[j];
124+
g = gcd(g, nums[j]);
125+
l = lcm(l, nums[j]);
126+
if (p == g * l) {
127+
ans = Math.max(ans, j - i + 1);
128+
}
129+
if (p > maxP) {
130+
break;
131+
}
132+
}
133+
}
134+
return ans;
135+
}
136+
137+
private int gcd(int a, int b) {
138+
while (b != 0) {
139+
int temp = b;
140+
b = a % b;
141+
a = temp;
142+
}
143+
return a;
144+
}
145+
146+
private int lcm(int a, int b) {
147+
return a / gcd(a, b) * b;
148+
}
149+
}
96150
```
97151

98152
#### C++
99153

100154
```cpp
101-
155+
class Solution {
156+
public:
157+
int maxLength(vector<int>& nums) {
158+
int mx = 0, ml = 1;
159+
for (int x : nums) {
160+
mx = max(mx, x);
161+
ml = lcm(ml, x);
162+
}
163+
164+
long long maxP = (long long) ml * mx;
165+
int n = nums.size();
166+
int ans = 0;
167+
for (int i = 0; i < n; ++i) {
168+
long long p = 1, g = 0, l = 1;
169+
for (int j = i; j < n; ++j) {
170+
p *= nums[j];
171+
g = gcd(g, nums[j]);
172+
l = lcm(l, nums[j]);
173+
174+
if (p == g * l) {
175+
ans = max(ans, j - i + 1);
176+
}
177+
if (p > maxP) {
178+
break;
179+
}
180+
}
181+
}
182+
return ans;
183+
}
184+
};
102185
```
103186

104187
#### Go
105188

106189
```go
107-
190+
func maxLength(nums []int) int {
191+
mx, ml := 0, 1
192+
for _, x := range nums {
193+
mx = max(mx, x)
194+
ml = lcm(ml, x)
195+
}
196+
maxP := ml * mx
197+
n := len(nums)
198+
ans := 0
199+
for i := 0; i < n; i++ {
200+
p, g, l := 1, 0, 1
201+
for j := i; j < n; j++ {
202+
p *= nums[j]
203+
g = gcd(g, nums[j])
204+
l = lcm(l, nums[j])
205+
if p == g*l {
206+
ans = max(ans, j-i+1)
207+
}
208+
if p > maxP {
209+
break
210+
}
211+
}
212+
}
213+
return ans
214+
}
215+
216+
func gcd(a, b int) int {
217+
for b != 0 {
218+
a, b = b, a%b
219+
}
220+
return a
221+
}
222+
223+
func lcm(a, b int) int {
224+
return a / gcd(a, b) * b
225+
}
108226
```
109227

110228
<!-- tabs:end -->

‎solution/3400-3499/3411.Maximum Subarray With Equal Products/Solution.cpp

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
public:
3+
int maxLength(vector<int>& nums) {
4+
int mx = 0, ml = 1;
5+
for (int x : nums) {
6+
mx = max(mx, x);
7+
ml = lcm(ml, x);
8+
}
9+
10+
long long maxP = (long long) ml * mx;
11+
int n = nums.size();
12+
int ans = 0;
13+
for (int i = 0; i < n; ++i) {
14+
long long p = 1, g = 0, l = 1;
15+
for (int j = i; j < n; ++j) {
16+
p *= nums[j];
17+
g = gcd(g, nums[j]);
18+
l = lcm(l, nums[j]);
19+
20+
if (p == g * l) {
21+
ans = max(ans, j - i + 1);
22+
}
23+
if (p > maxP) {
24+
break;
25+
}
26+
}
27+
}
28+
return ans;
29+
}
30+
};

‎solution/3400-3499/3411.Maximum Subarray With Equal Products/Solution.go

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
func maxLength(nums []int) int {
2+
mx, ml := 0, 1
3+
for _, x := range nums {
4+
mx = max(mx, x)
5+
ml = lcm(ml, x)
6+
}
7+
maxP := ml * mx
8+
n := len(nums)
9+
ans := 0
10+
for i := 0; i < n; i++ {
11+
p, g, l := 1, 0, 1
12+
for j := i; j < n; j++ {
13+
p *= nums[j]
14+
g = gcd(g, nums[j])
15+
l = lcm(l, nums[j])
16+
if p == g*l {
17+
ans = max(ans, j-i+1)
18+
}
19+
if p > maxP {
20+
break
21+
}
22+
}
23+
}
24+
return ans
25+
}
26+
27+
func gcd(a, b int) int {
28+
for b != 0 {
29+
a, b = b, a%b
30+
}
31+
return a
32+
}
33+
34+
func lcm(a, b int) int {
35+
return a / gcd(a, b) * b
36+
}

0 commit comments

Comments
 (0)