Skip to content

Commit 561c6a7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1950
No.1950.Maximum of Minimum Values in All Subarrays
1 parent 4efc3e3 commit 561c6a7

File tree

6 files changed

+468
-2
lines changed

6 files changed

+468
-2
lines changed

‎solution/1900-1999/1950.Maximum of Minimum Values in All Subarrays/README.md

Lines changed: 167 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -71,22 +71,188 @@ i = 3:
7171

7272
<!-- 这里可写通用的实现逻辑 -->
7373

74+
**方法一：单调栈**
75+
76+
我们可以先利用单调栈，求出每个位置的左边第一个比它小的位置 $left[i]$ 和右边第一个比它小的位置 $right[i]$，那么以 $nums[i]$ 为最小值的子数组的长度为 $m = right[i] - left[i] - 1$。
77+
78+
然后我们遍历数组，对于每个位置 $i$，更新 $ans[m - 1] = max(ans[m - 1], nums[i])$。
79+
80+
接着我们倒序遍历数组，更新 $ans[i] = max(ans[i], ans[i + 1])$。
81+
82+
最后返回 $ans$ 即可。
83+
84+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
85+
7486
<!-- tabs:start -->
7587

7688
### **Python3**
7789

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

8092
```python
81-
93+
class Solution:
94+
def findMaximums(self, nums: List[int]) -> List[int]:
95+
n = len(nums)
96+
left = [-1] * n
97+
right = [n] * n
98+
stk = []
99+
for i, x in enumerate(nums):
100+
while stk and nums[stk[-1]] >= x:
101+
stk.pop()
102+
if stk:
103+
left[i] = stk[-1]
104+
stk.append(i)
105+
stk = []
106+
for i in range(n - 1, -1, -1):
107+
while stk and nums[stk[-1]] >= nums[i]:
108+
stk.pop()
109+
if stk:
110+
right[i] = stk[-1]
111+
stk.append(i)
112+
ans = [0] * n
113+
for i in range(n):
114+
m = right[i] - left[i] - 1
115+
ans[m - 1] = max(ans[m - 1], nums[i])
116+
for i in range(n - 2, -1, -1):
117+
ans[i] = max(ans[i], ans[i + 1])
118+
return ans
82119
```
83120

84121
### **Java**
85122

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

88125
```java
126+
class Solution {
127+
public int[] findMaximums(int[] nums) {
128+
int n = nums.length;
129+
int[] left = new int[n];
130+
int[] right = new int[n];
131+
Arrays.fill(left, -1);
132+
Arrays.fill(right, n);
133+
Deque<Integer> stk = new ArrayDeque<>();
134+
for (int i = 0; i < n; ++i) {
135+
while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
136+
stk.pop();
137+
}
138+
if (!stk.isEmpty()) {
139+
left[i] = stk.peek();
140+
}
141+
stk.push(i);
142+
}
143+
stk.clear();
144+
for (int i = n - 1; i >= 0; --i) {
145+
while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
146+
stk.pop();
147+
}
148+
if (!stk.isEmpty()) {
149+
right[i] = stk.peek();
150+
}
151+
stk.push(i);
152+
}
153+
int[] ans = new int[n];
154+
for (int i = 0; i < n; ++i) {
155+
int m = right[i] - left[i] - 1;
156+
ans[m - 1] = Math.max(ans[m - 1], nums[i]);
157+
}
158+
for (int i = n - 2; i >= 0; --i) {
159+
ans[i] = Math.max(ans[i], ans[i + 1]);
160+
}
161+
return ans;
162+
}
163+
}
164+
```
165+
166+
### **C++**
167+
168+
```cpp
169+
class Solution {
170+
public:
171+
vector<int> findMaximums(vector<int>& nums) {
172+
int n = nums.size();
173+
vector<int> left(n, -1);
174+
vector<int> right(n, n);
175+
stack<int> stk;
176+
for (int i = 0; i < n; ++i) {
177+
while (!stk.empty() && nums[stk.top()] >= nums[i]) {
178+
stk.pop();
179+
}
180+
if (!stk.empty()) {
181+
left[i] = stk.top();
182+
}
183+
stk.push(i);
184+
}
185+
stk = stack<int>();
186+
for (int i = n - 1; i >= 0; --i) {
187+
while (!stk.empty() && nums[stk.top()] >= nums[i]) {
188+
stk.pop();
189+
}
190+
if (!stk.empty()) {
191+
right[i] = stk.top();
192+
}
193+
stk.push(i);
194+
}
195+
vector<int> ans(n);
196+
for (int i = 0; i < n; ++i) {
197+
int m = right[i] - left[i] - 1;
198+
ans[m - 1] = max(ans[m - 1], nums[i]);
199+
}
200+
for (int i = n - 2; i >= 0; --i) {
201+
ans[i] = max(ans[i], ans[i + 1]);
202+
}
203+
return ans;
204+
}
205+
};
206+
```
207+
208+
### **Go**
209+
210+
```go
211+
func findMaximums(nums []int) []int {
212+
n := len(nums)
213+
left := make([]int, n)
214+
right := make([]int, n)
215+
for i := range left {
216+
left[i], right[i] = -1, n
217+
}
218+
stk := []int{}
219+
for i, x := range nums {
220+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= x {
221+
stk = stk[:len(stk)-1]
222+
}
223+
if len(stk) > 0 {
224+
left[i] = stk[len(stk)-1]
225+
}
226+
stk = append(stk, i)
227+
}
228+
stk = []int{}
229+
for i := n - 1; i >= 0; i-- {
230+
x := nums[i]
231+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= x {
232+
stk = stk[:len(stk)-1]
233+
}
234+
if len(stk) > 0 {
235+
right[i] = stk[len(stk)-1]
236+
}
237+
stk = append(stk, i)
238+
}
239+
ans := make([]int, n)
240+
for i := range ans {
241+
m := right[i] - left[i] - 1
242+
ans[m-1] = max(ans[m-1], nums[i])
243+
}
244+
for i := n - 2; i >= 0; i-- {
245+
ans[i] = max(ans[i], ans[i+1])
246+
}
247+
return ans
248+
}
89249
250+
func max(a, b int) int {
251+
if a > b {
252+
return a
253+
}
254+
return b
255+
}
90256
```
91257

92258
### **...**

‎solution/1900-1999/1950.Maximum of Minimum Values in All Subarrays/README_EN.md

Lines changed: 155 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -74,13 +74,167 @@ i=3:
7474
### **Python3**
7575

7676
```python
77-
77+
class Solution:
78+
def findMaximums(self, nums: List[int]) -> List[int]:
79+
n = len(nums)
80+
left = [-1] * n
81+
right = [n] * n
82+
stk = []
83+
for i, x in enumerate(nums):
84+
while stk and nums[stk[-1]] >= x:
85+
stk.pop()
86+
if stk:
87+
left[i] = stk[-1]
88+
stk.append(i)
89+
stk = []
90+
for i in range(n - 1, -1, -1):
91+
while stk and nums[stk[-1]] >= nums[i]:
92+
stk.pop()
93+
if stk:
94+
right[i] = stk[-1]
95+
stk.append(i)
96+
ans = [0] * n
97+
for i in range(n):
98+
m = right[i] - left[i] - 1
99+
ans[m - 1] = max(ans[m - 1], nums[i])
100+
for i in range(n - 2, -1, -1):
101+
ans[i] = max(ans[i], ans[i + 1])
102+
return ans
78103
```
79104

80105
### **Java**
81106

82107
```java
108+
class Solution {
109+
public int[] findMaximums(int[] nums) {
110+
int n = nums.length;
111+
int[] left = new int[n];
112+
int[] right = new int[n];
113+
Arrays.fill(left, -1);
114+
Arrays.fill(right, n);
115+
Deque<Integer> stk = new ArrayDeque<>();
116+
for (int i = 0; i < n; ++i) {
117+
while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
118+
stk.pop();
119+
}
120+
if (!stk.isEmpty()) {
121+
left[i] = stk.peek();
122+
}
123+
stk.push(i);
124+
}
125+
stk.clear();
126+
for (int i = n - 1; i >= 0; --i) {
127+
while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
128+
stk.pop();
129+
}
130+
if (!stk.isEmpty()) {
131+
right[i] = stk.peek();
132+
}
133+
stk.push(i);
134+
}
135+
int[] ans = new int[n];
136+
for (int i = 0; i < n; ++i) {
137+
int m = right[i] - left[i] - 1;
138+
ans[m - 1] = Math.max(ans[m - 1], nums[i]);
139+
}
140+
for (int i = n - 2; i >= 0; --i) {
141+
ans[i] = Math.max(ans[i], ans[i + 1]);
142+
}
143+
return ans;
144+
}
145+
}
146+
```
147+
148+
### **C++**
149+
150+
```cpp
151+
class Solution {
152+
public:
153+
vector<int> findMaximums(vector<int>& nums) {
154+
int n = nums.size();
155+
vector<int> left(n, -1);
156+
vector<int> right(n, n);
157+
stack<int> stk;
158+
for (int i = 0; i < n; ++i) {
159+
while (!stk.empty() && nums[stk.top()] >= nums[i]) {
160+
stk.pop();
161+
}
162+
if (!stk.empty()) {
163+
left[i] = stk.top();
164+
}
165+
stk.push(i);
166+
}
167+
stk = stack<int>();
168+
for (int i = n - 1; i >= 0; --i) {
169+
while (!stk.empty() && nums[stk.top()] >= nums[i]) {
170+
stk.pop();
171+
}
172+
if (!stk.empty()) {
173+
right[i] = stk.top();
174+
}
175+
stk.push(i);
176+
}
177+
vector<int> ans(n);
178+
for (int i = 0; i < n; ++i) {
179+
int m = right[i] - left[i] - 1;
180+
ans[m - 1] = max(ans[m - 1], nums[i]);
181+
}
182+
for (int i = n - 2; i >= 0; --i) {
183+
ans[i] = max(ans[i], ans[i + 1]);
184+
}
185+
return ans;
186+
}
187+
};
188+
```
83189
190+
### **Go**
191+
192+
```go
193+
func findMaximums(nums []int) []int {
194+
n := len(nums)
195+
left := make([]int, n)
196+
right := make([]int, n)
197+
for i := range left {
198+
left[i], right[i] = -1, n
199+
}
200+
stk := []int{}
201+
for i, x := range nums {
202+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= x {
203+
stk = stk[:len(stk)-1]
204+
}
205+
if len(stk) > 0 {
206+
left[i] = stk[len(stk)-1]
207+
}
208+
stk = append(stk, i)
209+
}
210+
stk = []int{}
211+
for i := n - 1; i >= 0; i-- {
212+
x := nums[i]
213+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= x {
214+
stk = stk[:len(stk)-1]
215+
}
216+
if len(stk) > 0 {
217+
right[i] = stk[len(stk)-1]
218+
}
219+
stk = append(stk, i)
220+
}
221+
ans := make([]int, n)
222+
for i := range ans {
223+
m := right[i] - left[i] - 1
224+
ans[m-1] = max(ans[m-1], nums[i])
225+
}
226+
for i := n - 2; i >= 0; i-- {
227+
ans[i] = max(ans[i], ans[i+1])
228+
}
229+
return ans
230+
}
231+
232+
func max(a, b int) int {
233+
if a > b {
234+
return a
235+
}
236+
return b
237+
}
84238
```
85239

86240
### **...**

‎solution/1900-1999/1950.Maximum of Minimum Values in All Subarrays/Solution.cpp

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
class Solution {
2+
public:
3+
vector<int> findMaximums(vector<int>& nums) {
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+
while (!stk.empty() && nums[stk.top()] >= nums[i]) {
10+
stk.pop();
11+
}
12+
if (!stk.empty()) {
13+
left[i] = stk.top();
14+
}
15+
stk.push(i);
16+
}
17+
stk = stack<int>();
18+
for (int i = n - 1; i >= 0; --i) {
19+
while (!stk.empty() && nums[stk.top()] >= nums[i]) {
20+
stk.pop();
21+
}
22+
if (!stk.empty()) {
23+
right[i] = stk.top();
24+
}
25+
stk.push(i);
26+
}
27+
vector<int> ans(n);
28+
for (int i = 0; i < n; ++i) {
29+
int m = right[i] - left[i] - 1;
30+
ans[m - 1] = max(ans[m - 1], nums[i]);
31+
}
32+
for (int i = n - 2; i >= 0; --i) {
33+
ans[i] = max(ans[i], ans[i + 1]);
34+
}
35+
return ans;
36+
}
37+
};

0 commit comments

Comments
 (0)