Skip to content

Commit 7fc7b5c

Browse files
yanglbmeyanglbme
authored
feat: update solutions to lc problem: No.2444 (#4373)
1 parent 3aad112 commit 7fc7b5c

File tree

6 files changed

+147
-180
lines changed

6 files changed

+147
-180
lines changed

‎solution/2400-2499/2444.Count Subarrays With Fixed Bounds/README.md

+50-61
Original file line numberDiff line numberDiff line change
@@ -66,17 +66,17 @@ tags:
6666

6767
### 方法一：枚举右端点
6868

69-
由题意，我们可以知道，定界子数组的所有元素都在区间 `[minK, maxK]` 中，且最小值一定为 `minK`，最大值一定为 `maxK`。
69+
由题意，我们可以知道，定界子数组的所有元素都在区间 $[\textit{minK}, \textit{maxK}]$ 中，且最小值一定为 $\textit{minK}$，最大值一定为 $\textit{maxK}$。
7070

71-
我们遍历数组 $nums$，统计以 `nums[i]` 为右端点的定界子数组的个数，然后将所有的个数相加即可。
71+
我们遍历数组 $\textit{nums}$，统计以 $\textit{nums}[i]$ 为右端点的定界子数组的个数，然后将所有的个数相加即可。
7272

7373
具体实现逻辑如下：
7474

75-
1. 维护最近一个不在区间 `[minK, maxK]` 中的元素的下标 $k$，初始值为 $-1$。那么当前元素 `nums[i]` 的左端点一定大于 $k$。
76-
1. 维护最近一个值为 `minK` 的下标 $j_1$，最近一个值为 `maxK` 的下标 $j_2$，初始值均为 $-1$。那么当前元素 `nums[i]` 的左端点一定小于等于 $\min(j_1, j_2)$。
77-
1. 综上可知，以当前元素为右端点的定界子数组的个数为 $\max(0, \min(j_1, j_2) - k)$。累加所有的个数即可。
75+
1. 维护最近一个不在区间 $[\textit{minK}, \textit{maxK}]$ 中的元素的下标 $k$，初始值为 $-1$。那么当前元素 $\textit{nums}[i]$ 的左端点一定大于 $k$。
76+
2. 维护最近一个值为 $\textit{minK}$ 的下标 $j_1$，最近一个值为 $\textit{maxK}$ 的下标 $j_2$，初始值均为 $-1$。那么当前元素 $\textit{nums}[i]$ 的左端点一定小于等于 $\min(j_1, j_2)$。
77+
3. 综上可知，以当前元素为右端点的定界子数组的个数为 $\max\bigl(0,\ \min(j_1, j_2) - k\bigr)$。累加所有的个数即可。
7878

79-
时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 $nums$ 的长度。
79+
时间复杂度 $O(n)$，其中 $n$ 为数组 $\textit{nums}$ 的长度。空间复杂度 $O(1)$。
8080

8181
<!-- tabs:start -->
8282

@@ -130,10 +130,16 @@ public:
130130
long long countSubarrays(vector<int>& nums, int minK, int maxK) {
131131
long long ans = 0;
132132
int j1 = -1, j2 = -1, k = -1;
133-
for (int i = 0; i < nums.size(); ++i) {
134-
if (nums[i] < minK || nums[i] > maxK) k = i;
135-
if (nums[i] == minK) j1 = i;
136-
if (nums[i] == maxK) j2 = i;
133+
for (int i = 0; i < static_cast<int>(nums.size()); ++i) {
134+
if (nums[i] < minK || nums[i] > maxK) {
135+
k = i;
136+
}
137+
if (nums[i] == minK) {
138+
j1 = i;
139+
}
140+
if (nums[i] == maxK) {
141+
j2 = i;
142+
}
137143
ans += max(0, min(j1, j2) - k);
138144
}
139145
return ans;
@@ -167,23 +173,15 @@ func countSubarrays(nums []int, minK int, maxK int) int64 {
167173

168174
```ts
169175
function countSubarrays(nums: number[], minK: number, maxK: number): number {
170-
let res = 0;
171-
let minIndex = -1;
172-
let maxIndex = -1;
173-
let k = -1;
174-
nums.forEach((num, i) => {
175-
if (num === minK) {
176-
minIndex = i;
177-
}
178-
if (num === maxK) {
179-
maxIndex = i;
180-
}
181-
if (num < minK || num > maxK) {
182-
k = i;
183-
}
184-
res += Math.max(Math.min(minIndex, maxIndex) - k, 0);
185-
});
186-
return res;
176+
let ans = 0;
177+
let [j1, j2, k] = [-1, -1, -1];
178+
for (let i = 0; i < nums.length; ++i) {
179+
if (nums[i] < minK || nums[i] > maxK) k = i;
180+
if (nums[i] === minK) j1 = i;
181+
if (nums[i] === maxK) j2 = i;
182+
ans += Math.max(0, Math.min(j1, j2) - k);
183+
}
184+
return ans;
187185
}
188186
```
189187

@@ -192,54 +190,45 @@ function countSubarrays(nums: number[], minK: number, maxK: number): number {
192190
```rust
193191
impl Solution {
194192
pub fn count_subarrays(nums: Vec<i32>, min_k: i32, max_k: i32) -> i64 {
195-
let mut res = 0;
196-
let mut min_index = -1;
197-
let mut max_index = -1;
198-
let mut k = -1;
199-
for i in 0..nums.len() {
200-
let num = nums[i];
193+
let mut ans: i64 = 0;
194+
let mut j1: i64 = -1;
195+
let mut j2: i64 = -1;
196+
let mut k: i64 = -1;
197+
for (i, &v) in nums.iter().enumerate() {
201198
let i = i as i64;
202-
if num == min_k {
203-
min_index = i;
199+
if v < min_k || v > max_k {
200+
k = i;
204201
}
205-
if num == max_k {
206-
max_index = i;
202+
if v == min_k {
203+
j1 = i;
207204
}
208-
if num < min_k || num > max_k {
209-
k = i;
205+
if v == max_k {
206+
j2 = i;
207+
}
208+
let m = j1.min(j2);
209+
if m > k {
210+
ans += m - k;
210211
}
211-
res += (0).max(min_index.min(max_index) - k);
212212
}
213-
res
213+
ans
214214
}
215215
}
216216
```
217217

218218
#### C
219219

220220
```c
221-
#define max(a, b) (((a) > (b)) ? (a) : (b))
222-
#define min(a, b) (((a) < (b)) ? (a) : (b))
223-
224221
long long countSubarrays(int* nums, int numsSize, int minK, int maxK) {
225-
long long res = 0;
226-
int minIndex = -1;
227-
int maxIndex = -1;
228-
int k = -1;
229-
for (int i = 0; i < numsSize; i++) {
230-
int num = nums[i];
231-
if (num == minK) {
232-
minIndex = i;
233-
}
234-
if (num == maxK) {
235-
maxIndex = i;
236-
}
237-
if (num < minK || num > maxK) {
238-
k = i;
239-
}
240-
res += max(min(minIndex, maxIndex) - k, 0);
222+
long long ans = 0;
223+
int j1 = -1, j2 = -1, k = -1;
224+
for (int i = 0; i < numsSize; ++i) {
225+
if (nums[i] < minK || nums[i] > maxK) k = i;
226+
if (nums[i] == minK) j1 = i;
227+
if (nums[i] == maxK) j2 = i;
228+
int m = j1 < j2 ? j1 : j2;
229+
if (m > k) ans += (long long) (m - k);
241230
}
242-
return res;
231+
return ans;
243232
}
244233
```
245234

‎solution/2400-2499/2444.Count Subarrays With Fixed Bounds/README_EN.md

+51-62
Original file line numberDiff line numberDiff line change
@@ -65,19 +65,19 @@ tags:
6565

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

68-
### Solution 1: Enumeration of Right Endpoint
68+
### Solution 1: Enumerate the Right Endpoint
6969

70-
From the problem description, we know that all elements of the bounded subarray are in the interval `[minK, maxK]`, and the minimum value must be `minK`, and the maximum value must be `maxK`.
70+
According to the problem description, we know that all elements of a bounded subarray are within the range $[\textit{minK}, \textit{maxK}]$, and the minimum value must be $\textit{minK}$, while the maximum value must be $\textit{maxK}$.
7171

72-
We traverse the array $nums$, count the number of bounded subarrays with `nums[i]` as the right endpoint, and then add all the counts.
72+
We iterate through the array $\textit{nums}$ and count the number of bounded subarrays with $\textit{nums}[i]$ as the right endpoint. Then, we sum up all the counts.
7373

7474
The specific implementation logic is as follows:
7575

76-
1. Maintain the index $k$ of the most recent element not in the interval `[minK, maxK]`, initially set to $-1$. Therefore, the left endpoint of the current element `nums[i]` must be greater than $k$.
77-
1. Maintain the index $j_1$ of the most recent element with a value of `minK`, and the index $j_2$ of the most recent element with a value of `maxK`, both initially set to $-1$. Therefore, the left endpoint of the current element `nums[i]` must be less than or equal to $\min(j_1, j_2)$.
78-
1. In summary, the number of bounded subarrays with the current element as the right endpoint is $\max(0, \min(j_1, j_2) - k)$. Add up all the counts to get the result.
76+
1. Maintain the index $k$ of the most recent element that is not within the range $[\textit{minK}, \textit{maxK}]$, initialized to $-1$. The left endpoint of the current element $\textit{nums}[i]$ must be greater than $k$.
77+
2. Maintain the most recent index $j_1$ where the value is $\textit{minK}$ and the most recent index $j_2$ where the value is $\textit{maxK}$, both initialized to $-1$. The left endpoint of the current element $\textit{nums}[i]$ must be less than or equal to $\min(j_1, j_2)$.
78+
3. Based on the above, the number of bounded subarrays with the current element as the right endpoint is $\max\bigl(0,\ \min(j_1, j_2) - k\bigr)$. Accumulate all these counts to get the result.
7979

80-
The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the array $nums$.
80+
The time complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$. The space complexity is $O(1)$.
8181

8282
<!-- tabs:start -->
8383

@@ -131,10 +131,16 @@ public:
131131
long long countSubarrays(vector<int>& nums, int minK, int maxK) {
132132
long long ans = 0;
133133
int j1 = -1, j2 = -1, k = -1;
134-
for (int i = 0; i < nums.size(); ++i) {
135-
if (nums[i] < minK || nums[i] > maxK) k = i;
136-
if (nums[i] == minK) j1 = i;
137-
if (nums[i] == maxK) j2 = i;
134+
for (int i = 0; i < static_cast<int>(nums.size()); ++i) {
135+
if (nums[i] < minK || nums[i] > maxK) {
136+
k = i;
137+
}
138+
if (nums[i] == minK) {
139+
j1 = i;
140+
}
141+
if (nums[i] == maxK) {
142+
j2 = i;
143+
}
138144
ans += max(0, min(j1, j2) - k);
139145
}
140146
return ans;
@@ -168,23 +174,15 @@ func countSubarrays(nums []int, minK int, maxK int) int64 {
168174

169175
```ts
170176
function countSubarrays(nums: number[], minK: number, maxK: number): number {
171-
let res = 0;
172-
let minIndex = -1;
173-
let maxIndex = -1;
174-
let k = -1;
175-
nums.forEach((num, i) => {
176-
if (num === minK) {
177-
minIndex = i;
178-
}
179-
if (num === maxK) {
180-
maxIndex = i;
181-
}
182-
if (num < minK || num > maxK) {
183-
k = i;
184-
}
185-
res += Math.max(Math.min(minIndex, maxIndex) - k, 0);
186-
});
187-
return res;
177+
let ans = 0;
178+
let [j1, j2, k] = [-1, -1, -1];
179+
for (let i = 0; i < nums.length; ++i) {
180+
if (nums[i] < minK || nums[i] > maxK) k = i;
181+
if (nums[i] === minK) j1 = i;
182+
if (nums[i] === maxK) j2 = i;
183+
ans += Math.max(0, Math.min(j1, j2) - k);
184+
}
185+
return ans;
188186
}
189187
```
190188

@@ -193,54 +191,45 @@ function countSubarrays(nums: number[], minK: number, maxK: number): number {
193191
```rust
194192
impl Solution {
195193
pub fn count_subarrays(nums: Vec<i32>, min_k: i32, max_k: i32) -> i64 {
196-
let mut res = 0;
197-
let mut min_index = -1;
198-
let mut max_index = -1;
199-
let mut k = -1;
200-
for i in 0..nums.len() {
201-
let num = nums[i];
194+
let mut ans: i64 = 0;
195+
let mut j1: i64 = -1;
196+
let mut j2: i64 = -1;
197+
let mut k: i64 = -1;
198+
for (i, &v) in nums.iter().enumerate() {
202199
let i = i as i64;
203-
if num == min_k {
204-
min_index = i;
200+
if v < min_k || v > max_k {
201+
k = i;
205202
}
206-
if num == max_k {
207-
max_index = i;
203+
if v == min_k {
204+
j1 = i;
208205
}
209-
if num < min_k || num > max_k {
210-
k = i;
206+
if v == max_k {
207+
j2 = i;
208+
}
209+
let m = j1.min(j2);
210+
if m > k {
211+
ans += m - k;
211212
}
212-
res += (0).max(min_index.min(max_index) - k);
213213
}
214-
res
214+
ans
215215
}
216216
}
217217
```
218218

219219
#### C
220220

221221
```c
222-
#define max(a, b) (((a) > (b)) ? (a) : (b))
223-
#define min(a, b) (((a) < (b)) ? (a) : (b))
224-
225222
long long countSubarrays(int* nums, int numsSize, int minK, int maxK) {
226-
long long res = 0;
227-
int minIndex = -1;
228-
int maxIndex = -1;
229-
int k = -1;
230-
for (int i = 0; i < numsSize; i++) {
231-
int num = nums[i];
232-
if (num == minK) {
233-
minIndex = i;
234-
}
235-
if (num == maxK) {
236-
maxIndex = i;
237-
}
238-
if (num < minK || num > maxK) {
239-
k = i;
240-
}
241-
res += max(min(minIndex, maxIndex) - k, 0);
223+
long long ans = 0;
224+
int j1 = -1, j2 = -1, k = -1;
225+
for (int i = 0; i < numsSize; ++i) {
226+
if (nums[i] < minK || nums[i] > maxK) k = i;
227+
if (nums[i] == minK) j1 = i;
228+
if (nums[i] == maxK) j2 = i;
229+
int m = j1 < j2 ? j1 : j2;
230+
if (m > k) ans += (long long) (m - k);
242231
}
243-
return res;
232+
return ans;
244233
}
245234
```
246235

‎solution/2400-2499/2444.Count Subarrays With Fixed Bounds/Solution.c

+10-21
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,12 @@
1-
#define max(a, b) (((a) > (b)) ? (a) : (b))
2-
#define min(a, b) (((a) < (b)) ? (a) : (b))
3-
41
long long countSubarrays(int* nums, int numsSize, int minK, int maxK) {
5-
long long res = 0;
6-
int minIndex = -1;
7-
int maxIndex = -1;
8-
int k = -1;
9-
for (int i = 0; i < numsSize; i++) {
10-
int num = nums[i];
11-
if (num == minK) {
12-
minIndex = i;
13-
}
14-
if (num == maxK) {
15-
maxIndex = i;
16-
}
17-
if (num < minK || num > maxK) {
18-
k = i;
19-
}
20-
res += max(min(minIndex, maxIndex) - k, 0);
2+
long long ans = 0;
3+
int j1 = -1, j2 = -1, k = -1;
4+
for (int i = 0; i < numsSize; ++i) {
5+
if (nums[i] < minK || nums[i] > maxK) k = i;
6+
if (nums[i] == minK) j1 = i;
7+
if (nums[i] == maxK) j2 = i;
8+
int m = j1 < j2 ? j1 : j2;
9+
if (m > k) ans += (long long) (m - k);
2110
}
22-
return res;
23-
}
11+
return ans;
12+
}

‎solution/2400-2499/2444.Count Subarrays With Fixed Bounds/Solution.cpp

+11-5
Original file line numberDiff line numberDiff line change
@@ -3,12 +3,18 @@ class Solution {
33
long long countSubarrays(vector<int>& nums, int minK, int maxK) {
44
long long ans = 0;
55
int j1 = -1, j2 = -1, k = -1;
6-
for (int i = 0; i < nums.size(); ++i) {
7-
if (nums[i] < minK || nums[i] > maxK) k = i;
8-
if (nums[i] == minK) j1 = i;
9-
if (nums[i] == maxK) j2 = i;
6+
for (int i = 0; i < static_cast<int>(nums.size()); ++i) {
7+
if (nums[i] < minK || nums[i] > maxK) {
8+
k = i;
9+
}
10+
if (nums[i] == minK) {
11+
j1 = i;
12+
}
13+
if (nums[i] == maxK) {
14+
j2 = i;
15+
}
1016
ans += max(0, min(j1, j2) - k);
1117
}
1218
return ans;
1319
}
14-
};
20+
};

0 commit comments

Comments
 (0)