Skip to content

Commit d66a5fe

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1063 (doocs#1540)
No.1063.Number of Valid Subarrays
1 parent 977b6ac commit d66a5fe

File tree

7 files changed

+330
-2
lines changed

7 files changed

+330
-2
lines changed

‎solution/1000-1099/1063.Number of Valid Subarrays/README.md

Lines changed: 122 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,143 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一：单调栈**
56+
57+
题目实际上是求解每个位置 $i$ 的右边第一个小于 $nums[i]$ 的位置 $j$，那么以 $i$ 为左端点的有效子数组的个数就是 $j - i$。
58+
59+
我们可以使用单调栈来求解右边第一个小于 $nums[i]$ 的位置 $j$，具体做法是从右往左遍历数组，维护一个从栈顶到栈底严格单调递减的栈。如果栈不为空，并且栈顶元素大于等于 $nums[i]$，那么就将栈顶元素出栈，直到栈为空或者栈顶元素小于 $nums[i]$，此时栈顶元素就是右边第一个小于 $nums[i]$ 的位置 $j$，如果栈为空，那么 $j = n$。
60+
61+
接下来，我们将 $i$ 入栈，继续遍历数组，直到遍历结束，最后我们就可以得到每个位置 $i$ 的右边第一个小于 $nums[i]$ 的位置 $j$，从而得到以 $i$ 为左端点的有效子数组的个数 $j-i$，将所有的 $j-i$ 累加即可得到答案。
62+
63+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组的长度。
64+
5565
<!-- tabs:start -->
5666

5767
### **Python3**
5868

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

6171
```python
62-
72+
class Solution:
73+
def validSubarrays(self, nums: List[int]) -> int:
74+
n = len(nums)
75+
right = [n] * n
76+
stk = []
77+
for i in range(n - 1, -1, -1):
78+
while stk and nums[stk[-1]] >= nums[i]:
79+
stk.pop()
80+
if stk:
81+
right[i] = stk[-1]
82+
stk.append(i)
83+
return sum(j - i for i, j in enumerate(right))
6384
```
6485

6586
### **Java**
6687

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

6990
```java
91+
class Solution {
92+
public int validSubarrays(int[] nums) {
93+
int n = nums.length;
94+
int[] right = new int[n];
95+
Arrays.fill(right, n);
96+
Deque<Integer> stk = new ArrayDeque<>();
97+
for (int i = n - 1; i >= 0; --i) {
98+
while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
99+
stk.pop();
100+
}
101+
if (!stk.isEmpty()) {
102+
right[i] = stk.peek();
103+
}
104+
stk.push(i);
105+
}
106+
int ans = 0;
107+
for (int i = 0; i < n; ++i) {
108+
ans += right[i] - i;
109+
}
110+
return ans;
111+
}
112+
}
113+
```
114+
115+
### **C++**
116+
117+
```cpp
118+
class Solution {
119+
public:
120+
int validSubarrays(vector<int>& nums) {
121+
int n = nums.size();
122+
vector<int> right(n, n);
123+
stack<int> stk;
124+
for (int i = n - 1; ~i; --i) {
125+
while (stk.size() && nums[stk.top()] >= nums[i]) {
126+
stk.pop();
127+
}
128+
if (stk.size()) {
129+
right[i] = stk.top();
130+
}
131+
stk.push(i);
132+
}
133+
int ans = 0;
134+
for (int i = 0; i < n; ++i) {
135+
ans += right[i] - i;
136+
}
137+
return ans;
138+
}
139+
};
140+
```
141+
142+
### **Go**
143+
144+
```go
145+
func validSubarrays(nums []int) (ans int) {
146+
n := len(nums)
147+
right := make([]int, n)
148+
for i := range right {
149+
right[i] = n
150+
}
151+
stk := []int{}
152+
for i := n - 1; i >= 0; i-- {
153+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= nums[i] {
154+
stk = stk[:len(stk)-1]
155+
}
156+
if len(stk) > 0 {
157+
right[i] = stk[len(stk)-1]
158+
}
159+
stk = append(stk, i)
160+
}
161+
for i, j := range right {
162+
ans += j - i
163+
}
164+
return
165+
}
166+
```
70167

168+
### **TypeScript**
169+
170+
```ts
171+
func validSubarrays(nums []int) (ans int) {
172+
n := len(nums)
173+
right := make([]int, n)
174+
for i := range right {
175+
right[i] = n
176+
}
177+
stk := []int{}
178+
for i := n - 1; i >= 0; i-- {
179+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= nums[i] {
180+
stk = stk[:len(stk)-1]
181+
}
182+
if len(stk) > 0 {
183+
right[i] = stk[len(stk)-1]
184+
}
185+
stk = append(stk, i)
186+
}
187+
for i, j := range right {
188+
ans += j - i
189+
}
190+
return
191+
}
71192
```
72193

73194
### **...**

‎solution/1000-1099/1063.Number of Valid Subarrays/README_EN.md

Lines changed: 112 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,13 +48,124 @@
4848
### **Python3**
4949

5050
```python
51-
51+
class Solution:
52+
def validSubarrays(self, nums: List[int]) -> int:
53+
n = len(nums)
54+
right = [n] * n
55+
stk = []
56+
for i in range(n - 1, -1, -1):
57+
while stk and nums[stk[-1]] >= nums[i]:
58+
stk.pop()
59+
if stk:
60+
right[i] = stk[-1]
61+
stk.append(i)
62+
return sum(j - i for i, j in enumerate(right))
5263
```
5364

5465
### **Java**
5566

5667
```java
68+
class Solution {
69+
public int validSubarrays(int[] nums) {
70+
int n = nums.length;
71+
int[] right = new int[n];
72+
Arrays.fill(right, n);
73+
Deque<Integer> stk = new ArrayDeque<>();
74+
for (int i = n - 1; i >= 0; --i) {
75+
while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
76+
stk.pop();
77+
}
78+
if (!stk.isEmpty()) {
79+
right[i] = stk.peek();
80+
}
81+
stk.push(i);
82+
}
83+
int ans = 0;
84+
for (int i = 0; i < n; ++i) {
85+
ans += right[i] - i;
86+
}
87+
return ans;
88+
}
89+
}
90+
```
91+
92+
### **C++**
93+
94+
```cpp
95+
class Solution {
96+
public:
97+
int validSubarrays(vector<int>& nums) {
98+
int n = nums.size();
99+
vector<int> right(n, n);
100+
stack<int> stk;
101+
for (int i = n - 1; ~i; --i) {
102+
while (stk.size() && nums[stk.top()] >= nums[i]) {
103+
stk.pop();
104+
}
105+
if (stk.size()) {
106+
right[i] = stk.top();
107+
}
108+
stk.push(i);
109+
}
110+
int ans = 0;
111+
for (int i = 0; i < n; ++i) {
112+
ans += right[i] - i;
113+
}
114+
return ans;
115+
}
116+
};
117+
```
118+
119+
### **Go**
120+
121+
```go
122+
func validSubarrays(nums []int) (ans int) {
123+
n := len(nums)
124+
right := make([]int, n)
125+
for i := range right {
126+
right[i] = n
127+
}
128+
stk := []int{}
129+
for i := n - 1; i >= 0; i-- {
130+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= nums[i] {
131+
stk = stk[:len(stk)-1]
132+
}
133+
if len(stk) > 0 {
134+
right[i] = stk[len(stk)-1]
135+
}
136+
stk = append(stk, i)
137+
}
138+
for i, j := range right {
139+
ans += j - i
140+
}
141+
return
142+
}
143+
```
57144

145+
### **TypeScript**
146+
147+
```ts
148+
func validSubarrays(nums []int) (ans int) {
149+
n := len(nums)
150+
right := make([]int, n)
151+
for i := range right {
152+
right[i] = n
153+
}
154+
stk := []int{}
155+
for i := n - 1; i >= 0; i-- {
156+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= nums[i] {
157+
stk = stk[:len(stk)-1]
158+
}
159+
if len(stk) > 0 {
160+
right[i] = stk[len(stk)-1]
161+
}
162+
stk = append(stk, i)
163+
}
164+
for i, j := range right {
165+
ans += j - i
166+
}
167+
return
168+
}
58169
```
59170

60171
### **...**

‎solution/1000-1099/1063.Number of Valid Subarrays/Solution.cpp

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
int validSubarrays(vector<int>& nums) {
4+
int n = nums.size();
5+
vector<int> right(n, n);
6+
stack<int> stk;
7+
for (int i = n - 1; ~i; --i) {
8+
while (stk.size() && nums[stk.top()] >= nums[i]) {
9+
stk.pop();
10+
}
11+
if (stk.size()) {
12+
right[i] = stk.top();
13+
}
14+
stk.push(i);
15+
}
16+
int ans = 0;
17+
for (int i = 0; i < n; ++i) {
18+
ans += right[i] - i;
19+
}
20+
return ans;
21+
}
22+
};

‎solution/1000-1099/1063.Number of Valid Subarrays/Solution.go

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
func validSubarrays(nums []int) (ans int) {
2+
n := len(nums)
3+
right := make([]int, n)
4+
for i := range right {
5+
right[i] = n
6+
}
7+
stk := []int{}
8+
for i := n - 1; i >= 0; i-- {
9+
for len(stk) > 0 && nums[stk[len(stk)-1]] >= nums[i] {
10+
stk = stk[:len(stk)-1]
11+
}
12+
if len(stk) > 0 {
13+
right[i] = stk[len(stk)-1]
14+
}
15+
stk = append(stk, i)
16+
}
17+
for i, j := range right {
18+
ans += j - i
19+
}
20+
return
21+
}

‎solution/1000-1099/1063.Number of Valid Subarrays/Solution.java

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public int validSubarrays(int[] nums) {
3+
int n = nums.length;
4+
int[] right = new int[n];
5+
Arrays.fill(right, n);
6+
Deque<Integer> stk = new ArrayDeque<>();
7+
for (int i = n - 1; i >= 0; --i) {
8+
while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
9+
stk.pop();
10+
}
11+
if (!stk.isEmpty()) {
12+
right[i] = stk.peek();
13+
}
14+
stk.push(i);
15+
}
16+
int ans = 0;
17+
for (int i = 0; i < n; ++i) {
18+
ans += right[i] - i;
19+
}
20+
return ans;
21+
}
22+
}

‎solution/1000-1099/1063.Number of Valid Subarrays/Solution.py

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
class Solution:
2+
def validSubarrays(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
right = [n] * n
5+
stk = []
6+
for i in range(n - 1, -1, -1):
7+
while stk and nums[stk[-1]] >= nums[i]:
8+
stk.pop()
9+
if stk:
10+
right[i] = stk[-1]
11+
stk.append(i)
12+
return sum(j - i for i, j in enumerate(right))

‎solution/1000-1099/1063.Number of Valid Subarrays/Solution.ts

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
function validSubarrays(nums: number[]): number {
2+
const n = nums.length;
3+
const right: number[] = Array(n).fill(n);
4+
const stk: number[] = [];
5+
for (let i = n - 1; ~i; --i) {
6+
while (stk.length && nums[stk.at(-1)] >= nums[i]) {
7+
stk.pop();
8+
}
9+
if (stk.length) {
10+
right[i] = stk.at(-1);
11+
}
12+
stk.push(i);
13+
}
14+
let ans = 0;
15+
for (let i = 0; i < n; ++i) {
16+
ans += right[i] - i;
17+
}
18+
return ans;
19+
}

0 commit comments

Comments
 (0)