Skip to content

Commit ba2b770

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1793
No.1793.Maximum Score of a Good Subarray
1 parent 2d287d5 commit ba2b770

File tree

6 files changed

+455
-2
lines changed

6 files changed

+455
-2
lines changed

‎solution/1700-1799/1793.Maximum Score of a Good Subarray/README.md

+160-1
Original file line numberDiff line numberDiff line change
@@ -42,22 +42,181 @@
4242

4343
<!-- 这里可写通用的实现逻辑 -->
4444

45+
**方法一：单调栈**
46+
47+
我们可以枚举 `nums` 中的每个元素 $nums[i]$ 作为子数组的最小值，利用单调栈找出其左边第一个小于 $nums[i]$ 的位置 $left[i]$ 和右边第一个小于等于 $nums[i]$ 的位置 $right[i]$，则以 $nums[i]$ 为最小值的子数组的分数为 $nums[i] \times (right[i] - left[i] - 1)$。
48+
49+
需要注意的是，只有当左右边界 $left[i]$ 和 $right[i]$ 满足 $left[i]+1 \leq k \leq right[i]-1$ 时，答案才有可能更新。
50+
51+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
52+
4553
<!-- tabs:start -->
4654

4755
### **Python3**
4856

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

5159
```python
52-
60+
class Solution:
61+
def maximumScore(self, nums: List[int], k: int) -> int:
62+
n = len(nums)
63+
left = [-1] * n
64+
right = [n] * n
65+
stk = []
66+
for i, v in enumerate(nums):
67+
while stk and nums[stk[-1]] >= v:
68+
stk.pop()
69+
if stk:
70+
left[i] = stk[-1]
71+
stk.append(i)
72+
stk = []
73+
for i in range(n - 1, -1, -1):
74+
v = nums[i]
75+
while stk and nums[stk[-1]] > v:
76+
stk.pop()
77+
if stk:
78+
right[i] = stk[-1]
79+
stk.append(i)
80+
ans = 0
81+
for i, v in enumerate(nums):
82+
if left[i] + 1 <= k <= right[i] - 1:
83+
ans = max(ans, v * (right[i] - left[i] - 1))
84+
return ans
5385
```
5486

5587
### **Java**
5688

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

5991
```java
92+
class Solution {
93+
public int maximumScore(int[] nums, int k) {
94+
int n = nums.length;
95+
int[] left = new int[n];
96+
int[] right = new int[n];
97+
Arrays.fill(left, -1);
98+
Arrays.fill(right, n);
99+
Deque<Integer> stk = new ArrayDeque<>();
100+
for (int i = 0; i < n; ++i) {
101+
int v = nums[i];
102+
while (!stk.isEmpty() && nums[stk.peek()] >= v) {
103+
stk.pop();
104+
}
105+
if (!stk.isEmpty()) {
106+
left[i] = stk.peek();
107+
}
108+
stk.push(i);
109+
}
110+
stk.clear();
111+
for (int i = n - 1; i >= 0; --i) {
112+
int v = nums[i];
113+
while (!stk.isEmpty() && nums[stk.peek()] > v) {
114+
stk.pop();
115+
}
116+
if (!stk.isEmpty()) {
117+
right[i] = stk.peek();
118+
}
119+
stk.push(i);
120+
}
121+
int ans = 0;
122+
for (int i = 0; i < n; ++i) {
123+
if (left[i] + 1 <= k && k <= right[i] - 1) {
124+
ans = Math.max(ans, nums[i] * (right[i] - left[i] - 1));
125+
}
126+
}
127+
return ans;
128+
}
129+
}
130+
```
131+
132+
### **C++**
133+
134+
```cpp
135+
class Solution {
136+
public:
137+
int maximumScore(vector<int>& nums, int k) {
138+
int n = nums.size();
139+
vector<int> left(n, -1);
140+
vector<int> right(n, n);
141+
stack<int> stk;
142+
for (int i = 0; i < n; ++i) {
143+
int v = nums[i];
144+
while (!stk.empty() && nums[stk.top()] >= v) {
145+
stk.pop();
146+
}
147+
if (!stk.empty()) {
148+
left[i] = stk.top();
149+
}
150+
stk.push(i);
151+
}
152+
stk = stack<int>();
153+
for (int i = n - 1; i >= 0; --i) {
154+
int v = nums[i];
155+
while (!stk.empty() && nums[stk.top()] > v) {
156+
stk.pop();
157+
}
158+
if (!stk.empty()) {
159+
right[i] = stk.top();
160+
}
161+
stk.push(i);
162+
}
163+
int ans = 0;
164+
for (int i = 0; i < n; ++i) {
165+
if (left[i] + 1 <= k && k <= right[i] - 1) {
166+
ans = max(ans, nums[i] * (right[i] - left[i] - 1));
167+
}
168+
}
169+
return ans;
170+
}
171+
};
172+
```
60173
174+
### **Go**
175+
176+
```go
177+
func maximumScore(nums []int, k int) (ans int) {
178+
n := len(nums)
179+
left := make([]int, n)
180+
right := make([]int, n)
181+
for i := range left {
182+
left[i] = -1
183+
right[i] = n
184+
}
185+
stk := []int{}
186+
for i, v := range nums {
187+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= v {
188+
stk = stk[:len(stk)-1]
189+
}
190+
if len(stk) > 0 {
191+
left[i] = stk[len(stk)-1]
192+
}
193+
stk = append(stk, i)
194+
}
195+
stk = []int{}
196+
for i := n - 1; i >= 0; i-- {
197+
v := nums[i]
198+
for len(stk) > 0 && nums[stk[len(stk)-1]] > v {
199+
stk = stk[:len(stk)-1]
200+
}
201+
if len(stk) > 0 {
202+
right[i] = stk[len(stk)-1]
203+
}
204+
stk = append(stk, i)
205+
}
206+
for i, v := range nums {
207+
if left[i]+1 <= k && k <= right[i]-1 {
208+
ans = max(ans, v*(right[i]-left[i]-1))
209+
}
210+
}
211+
return
212+
}
213+
214+
func max(a, b int) int {
215+
if a > b {
216+
return a
217+
}
218+
return b
219+
}
61220
```
62221

63222
### **...**

‎solution/1700-1799/1793.Maximum Score of a Good Subarray/README_EN.md

+152-1
Original file line numberDiff line numberDiff line change
@@ -43,13 +43,164 @@
4343
### **Python3**
4444

4545
```python
46-
46+
class Solution:
47+
def maximumScore(self, nums: List[int], k: int) -> int:
48+
n = len(nums)
49+
left = [-1] * n
50+
right = [n] * n
51+
stk = []
52+
for i, v in enumerate(nums):
53+
while stk and nums[stk[-1]] >= v:
54+
stk.pop()
55+
if stk:
56+
left[i] = stk[-1]
57+
stk.append(i)
58+
stk = []
59+
for i in range(n - 1, -1, -1):
60+
v = nums[i]
61+
while stk and nums[stk[-1]] > v:
62+
stk.pop()
63+
if stk:
64+
right[i] = stk[-1]
65+
stk.append(i)
66+
ans = 0
67+
for i, v in enumerate(nums):
68+
if left[i] + 1 <= k <= right[i] - 1:
69+
ans = max(ans, v * (right[i] - left[i] - 1))
70+
return ans
4771
```
4872

4973
### **Java**
5074

5175
```java
76+
class Solution {
77+
public int maximumScore(int[] nums, int k) {
78+
int n = nums.length;
79+
int[] left = new int[n];
80+
int[] right = new int[n];
81+
Arrays.fill(left, -1);
82+
Arrays.fill(right, n);
83+
Deque<Integer> stk = new ArrayDeque<>();
84+
for (int i = 0; i < n; ++i) {
85+
int v = nums[i];
86+
while (!stk.isEmpty() && nums[stk.peek()] >= v) {
87+
stk.pop();
88+
}
89+
if (!stk.isEmpty()) {
90+
left[i] = stk.peek();
91+
}
92+
stk.push(i);
93+
}
94+
stk.clear();
95+
for (int i = n - 1; i >= 0; --i) {
96+
int v = nums[i];
97+
while (!stk.isEmpty() && nums[stk.peek()] > v) {
98+
stk.pop();
99+
}
100+
if (!stk.isEmpty()) {
101+
right[i] = stk.peek();
102+
}
103+
stk.push(i);
104+
}
105+
int ans = 0;
106+
for (int i = 0; i < n; ++i) {
107+
if (left[i] + 1 <= k && k <= right[i] - 1) {
108+
ans = Math.max(ans, nums[i] * (right[i] - left[i] - 1));
109+
}
110+
}
111+
return ans;
112+
}
113+
}
114+
```
115+
116+
### **C++**
117+
118+
```cpp
119+
class Solution {
120+
public:
121+
int maximumScore(vector<int>& nums, int k) {
122+
int n = nums.size();
123+
vector<int> left(n, -1);
124+
vector<int> right(n, n);
125+
stack<int> stk;
126+
for (int i = 0; i < n; ++i) {
127+
int v = nums[i];
128+
while (!stk.empty() && nums[stk.top()] >= v) {
129+
stk.pop();
130+
}
131+
if (!stk.empty()) {
132+
left[i] = stk.top();
133+
}
134+
stk.push(i);
135+
}
136+
stk = stack<int>();
137+
for (int i = n - 1; i >= 0; --i) {
138+
int v = nums[i];
139+
while (!stk.empty() && nums[stk.top()] > v) {
140+
stk.pop();
141+
}
142+
if (!stk.empty()) {
143+
right[i] = stk.top();
144+
}
145+
stk.push(i);
146+
}
147+
int ans = 0;
148+
for (int i = 0; i < n; ++i) {
149+
if (left[i] + 1 <= k && k <= right[i] - 1) {
150+
ans = max(ans, nums[i] * (right[i] - left[i] - 1));
151+
}
152+
}
153+
return ans;
154+
}
155+
};
156+
```
52157
158+
### **Go**
159+
160+
```go
161+
func maximumScore(nums []int, k int) (ans int) {
162+
n := len(nums)
163+
left := make([]int, n)
164+
right := make([]int, n)
165+
for i := range left {
166+
left[i] = -1
167+
right[i] = n
168+
}
169+
stk := []int{}
170+
for i, v := range nums {
171+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= v {
172+
stk = stk[:len(stk)-1]
173+
}
174+
if len(stk) > 0 {
175+
left[i] = stk[len(stk)-1]
176+
}
177+
stk = append(stk, i)
178+
}
179+
stk = []int{}
180+
for i := n - 1; i >= 0; i-- {
181+
v := nums[i]
182+
for len(stk) > 0 && nums[stk[len(stk)-1]] > v {
183+
stk = stk[:len(stk)-1]
184+
}
185+
if len(stk) > 0 {
186+
right[i] = stk[len(stk)-1]
187+
}
188+
stk = append(stk, i)
189+
}
190+
for i, v := range nums {
191+
if left[i]+1 <= k && k <= right[i]-1 {
192+
ans = max(ans, v*(right[i]-left[i]-1))
193+
}
194+
}
195+
return
196+
}
197+
198+
func max(a, b int) int {
199+
if a > b {
200+
return a
201+
}
202+
return b
203+
}
53204
```
54205

55206
### **...**

‎solution/1700-1799/1793.Maximum Score of a Good Subarray/Solution.cpp

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
class Solution {
2+
public:
3+
int maximumScore(vector<int>& nums, int k) {
4+
int n = nums.size();
5+
vector<int> left(n, -1);
6+
vector<int> right(n, n);
7+
stack<int> stk;
8+
for (int i = 0; i < n; ++i) {
9+
int v = nums[i];
10+
while (!stk.empty() && nums[stk.top()] >= v) {
11+
stk.pop();
12+
}
13+
if (!stk.empty()) {
14+
left[i] = stk.top();
15+
}
16+
stk.push(i);
17+
}
18+
stk = stack<int>();
19+
for (int i = n - 1; i >= 0; --i) {
20+
int v = nums[i];
21+
while (!stk.empty() && nums[stk.top()] > v) {
22+
stk.pop();
23+
}
24+
if (!stk.empty()) {
25+
right[i] = stk.top();
26+
}
27+
stk.push(i);
28+
}
29+
int ans = 0;
30+
for (int i = 0; i < n; ++i) {
31+
if (left[i] + 1 <= k && k <= right[i] - 1) {
32+
ans = max(ans, nums[i] * (right[i] - left[i] - 1));
33+
}
34+
}
35+
return ans;
36+
}
37+
};

0 commit comments

Comments
 (0)