feat: add solutions to lc problem: No.0795

No.0795.Number of Subarrays with Bounded Maximum

Author: yanglbme

solution/0700-0799/0795.Number of Subarrays with Bounded Maximum/README.md

@@ -41,11 +41,29 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：单调栈**
+**方法一：区间计数**
 
-我们可以枚举数组中每个元素作为子数组的最大值，然后统计以该元素为最大值的子数组的个数。问题转化为求出每个元素 $nums[i]$ 左侧第一个大于该元素的下标 $l[i]$，右侧第一个大于等于该元素的下标 $r[i]$，则以该元素为最大值的子数组的个数为 $(i - l[i]) \times (r[i] - i)$。
+题目要我们统计数组 `nums` 中，最大值在区间 $[left, right]$ 范围内的子数组个数。
 
-我们可以使用单调栈求出 $l[i]$ 和 $r[i]$。
+对于区间 $[left,..right]$ 问题，我们可以考虑将其转换为 $[0,..right]$ 然后再减去 $[0,..left-1]$ 的问题，即：
+
+$$
+ans = \sum_{i=0}^{right} ans_i -  \sum_{i=0}^{left-1} ans_i
+$$
+
+对于本题，我们设计一个函数 $f(x)$，表示数组 `nums` 中，最大值不超过 $x$ 的子数组个数。那么答案为 $f(right) - f(left-1)$。函数 $f(x)$ 的执行逻辑如下：
+
+-   用变量 $cnt$ 记录最大值不超过 $x$ 的子数组的个数，用 $t$ 记录当前子数组的长度。
+-   遍历数组 `nums`，对于每个元素 $nums[i]$，如果 $nums[i] \leq x$，则当前子数组的长度加一，即 $t=t+1$，否则当前子数组的长度重置为 0，即 $t=0$。然后将当前子数组的长度加到 $cnt$ 中，即 $cnt = cnt + t$。
+-   遍历结束，将 $cnt$ 返回即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+
+**方法二：单调栈 + 枚举元素计算贡献**
+
+我们还可以枚举数组中每个元素 $nums[i]$ 作为子数组的最大值，然后统计以该元素为最大值的子数组的个数。问题转化为求出每个元素 $nums[i]$ 左侧第一个大于该元素的下标 $l[i]$，右侧第一个大于等于该元素的下标 $r[i]$，则以该元素为最大值的子数组的个数为 $(i - l[i]) \times (r[i] - i)$。
+
+我们可以使用单调栈方便地求出 $l[i]$ 和 $r[i]$。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。
 
@@ -57,6 +75,19 @@
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+class Solution:
+    def numSubarrayBoundedMax(self, nums: List[int], left: int, right: int) -> int:
+        def f(x):
+            cnt = t = 0
+            for v in nums:
+                t = 0 if v > x else t + 1
+                cnt += t
+            return cnt
+
+        return f(right) - f(left - 1)
+```
+
 ```python
 class Solution:
     def numSubarrayBoundedMax(self, nums: List[int], left: int, right: int) -> int:
@@ -83,6 +114,23 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    public int numSubarrayBoundedMax(int[] nums, int left, int right) {
+        return f(nums, right) - f(nums, left - 1);
+    }
+
+    private int f(int[] nums, int x) {
+        int cnt = 0, t = 0;
+        for (int v : nums) {
+            t = v > x ? 0 : t + 1;
+            cnt += t;
+        }
+        return cnt;
+    }
+}
+```
+
 ```java
 class Solution {
     public int numSubarrayBoundedMax(int[] nums, int left, int right) {
@@ -126,6 +174,23 @@ class Solution {
 
 ### **C++**
 
+```cpp
+class Solution {
+public:
+    int numSubarrayBoundedMax(vector<int>& nums, int left, int right) {
+        auto f = [&](int x) {
+            int cnt = 0, t = 0;
+            for (int& v : nums) {
+                t = v > x ? 0 : t + 1;
+                cnt += t;
+            }
+            return cnt;
+        };
+        return f(right) - f(left -1);
+    }
+};
+```
+
 ```cpp
 class Solution {
 public:
@@ -160,6 +225,23 @@ public:
 
 ### **Go**
 
+```go
+func numSubarrayBoundedMax(nums []int, left int, right int) int {
+	f := func(x int) (cnt int) {
+		t := 0
+		for _, v := range nums {
+			t++
+			if v > x {
+				t = 0
+			}
+			cnt += t
+		}
+		return
+	}
+	return f(right) - f(left-1)
+}
+```
+
 ```go
 func numSubarrayBoundedMax(nums []int, left int, right int) (ans int) {
 	n := len(nums)

solution/0700-0799/0795.Number of Subarrays with Bounded Maximum/README_EN.md

@@ -39,6 +39,19 @@
 
 ### **Python3**
 
+```python
+class Solution:
+    def numSubarrayBoundedMax(self, nums: List[int], left: int, right: int) -> int:
+        def f(x):
+            cnt = t = 0
+            for v in nums:
+                t = 0 if v > x else t + 1
+                cnt += t
+            return cnt
+
+        return f(right) - f(left - 1)
+```
+
 ```python
 class Solution:
     def numSubarrayBoundedMax(self, nums: List[int], left: int, right: int) -> int:
@@ -63,6 +76,23 @@ class Solution:
 
 ### **Java**
 
+```java
+class Solution {
+    public int numSubarrayBoundedMax(int[] nums, int left, int right) {
+        return f(nums, right) - f(nums, left - 1);
+    }
+
+    private int f(int[] nums, int x) {
+        int cnt = 0, t = 0;
+        for (int v : nums) {
+            t = v > x ? 0 : t + 1;
+            cnt += t;
+        }
+        return cnt;
+    }
+}
+```
+
 ```java
 class Solution {
     public int numSubarrayBoundedMax(int[] nums, int left, int right) {
@@ -106,6 +136,23 @@ class Solution {
 
 ### **C++**
 
+```cpp
+class Solution {
+public:
+    int numSubarrayBoundedMax(vector<int>& nums, int left, int right) {
+        auto f = [&](int x) {
+            int cnt = 0, t = 0;
+            for (int& v : nums) {
+                t = v > x ? 0 : t + 1;
+                cnt += t;
+            }
+            return cnt;
+        };
+        return f(right) - f(left -1);
+    }
+};
+```
+
 ```cpp
 class Solution {
 public:
@@ -140,6 +187,23 @@ public:
 
 ### **Go**
 
+```go
+func numSubarrayBoundedMax(nums []int, left int, right int) int {
+	f := func(x int) (cnt int) {
+		t := 0
+		for _, v := range nums {
+			t++
+			if v > x {
+				t = 0
+			}
+			cnt += t
+		}
+		return
+	}
+	return f(right) - f(left-1)
+}
+```
+
 ```go
 func numSubarrayBoundedMax(nums []int, left int, right int) (ans int) {
 	n := len(nums)

solution/0700-0799/0795.Number of Subarrays with Bounded Maximum/Solution.cpp

@@ -1,29 +1,14 @@
 class Solution {
 public:
     int numSubarrayBoundedMax(vector<int>& nums, int left, int right) {
-        int n = nums.size();
-        vector<int> l(n, -1);
-        vector<int> r(n, n);
-        stack<int> stk;
-        for (int i = 0; i < n; ++i) {
-            int v = nums[i];
-            while (!stk.empty() && nums[stk.top()] <= v) stk.pop();
-            if (!stk.empty()) l[i] = stk.top();
-            stk.push(i);
-        }
-        stk = stack<int>();
-        for (int i = n - 1; ~i; --i) {
-            int v = nums[i];
-            while (!stk.empty() && nums[stk.top()] < v) stk.pop();
-            if (!stk.empty()) r[i] = stk.top();
-            stk.push(i);
-        }
-        int ans = 0;
-        for (int i = 0; i < n; ++i) {
-            if (left <= nums[i] && nums[i] <= right) {
-                ans += (i - l[i]) * (r[i] - i);
+        auto f = [&](int x) {
+            int cnt = 0, t = 0;
+            for (int& v : nums) {
+                t = v > x ? 0 : t + 1;
+                cnt += t;
             }
-        }
-        return ans;
+            return cnt;
+        };
+        return f(right) - f(left -1);
     }
 };

solution/0700-0799/0795.Number of Subarrays with Bounded Maximum/Solution.go

@@ -1,35 +1,14 @@
-func numSubarrayBoundedMax(nums []int, left int, right int) (ans int) {
-	n := len(nums)
-	l := make([]int, n)
-	r := make([]int, n)
-	for i := range l {
-		l[i], r[i] = -1, n
-	}
-	stk := []int{}
-	for i, v := range nums {
-		for len(stk) > 0 && nums[stk[len(stk)-1]] <= v {
-			stk = stk[:len(stk)-1]
-		}
-		if len(stk) > 0 {
-			l[i] = stk[len(stk)-1]
-		}
-		stk = append(stk, i)
-	}
-	stk = []int{}
-	for i := n - 1; i >= 0; i-- {
-		v := nums[i]
-		for len(stk) > 0 && nums[stk[len(stk)-1]] < v {
-			stk = stk[:len(stk)-1]
-		}
-		if len(stk) > 0 {
-			r[i] = stk[len(stk)-1]
-		}
-		stk = append(stk, i)
-	}
-	for i, v := range nums {
-		if left <= v && v <= right {
-			ans += (i - l[i]) * (r[i] - i)
-		}
-	}
-	return
+func numSubarrayBoundedMax(nums []int, left int, right int) int {
+	f := func(x int) (cnt int) {
+		t := 0
+		for _, v := range nums {
+			t++
+			if v > x {
+				t = 0
+			}
+			cnt += t
+		}
+		return
+	}
+	return f(right) - f(left-1)
 }

solution/0700-0799/0795.Number of Subarrays with Bounded Maximum/Solution.java

@@ -1,38 +1,14 @@
 class Solution {
     public int numSubarrayBoundedMax(int[] nums, int left, int right) {
-        int n = nums.length;
-        int[] l = new int[n];
-        int[] r = new int[n];
-        Arrays.fill(l, -1);
-        Arrays.fill(r, n);
-        Deque<Integer> stk = new ArrayDeque<>();
-        for (int i = 0; i < n; ++i) {
-            int v = nums[i];
-            while (!stk.isEmpty() && nums[stk.peek()] <= v) {
-                stk.pop();
-            }
-            if (!stk.isEmpty()) {
-                l[i] = stk.peek();
-            }
-            stk.push(i);
-        }
-        stk.clear();
-        for (int i = n - 1; i >= 0; --i) {
-            int v = nums[i];
-            while (!stk.isEmpty() && nums[stk.peek()] < v) {
-                stk.pop();
-            }
-            if (!stk.isEmpty()) {
-                r[i] = stk.peek();
-            }
-            stk.push(i);
-        }
-        int ans = 0;
-        for (int i = 0; i < n; ++i) {
-            if (left <= nums[i] && nums[i] <= right) {
-                ans += (i - l[i]) * (r[i] - i);
-            }
+        return f(nums, right) - f(nums, left - 1);
+    }
+
+    private int f(int[] nums, int x) {
+        int cnt = 0, t = 0;
+        for (int v : nums) {
+            t = v > x ? 0 : t + 1;
+            cnt += t;
         }
-        return ans;
+        return cnt;
     }
 }

solution/0700-0799/0795.Number of Subarrays with Bounded Maximum/Solution.py

@@ -1,21 +1,10 @@
 class Solution:
     def numSubarrayBoundedMax(self, nums: List[int], left: int, right: int) -> int:
-        n = len(nums)
-        l, r = [-1] * n, [n] * n
-        stk = []
-        for i, v in enumerate(nums):
-            while stk and nums[stk[-1]] <= v:
-                stk.pop()
-            if stk:
-                l[i] = stk[-1]
-            stk.append(i)
-        stk = []
-        for i in range(n - 1, -1, -1):
-            while stk and nums[stk[-1]] < nums[i]:
-                stk.pop()
-            if stk:
-                r[i] = stk[-1]
-            stk.append(i)
-        return sum(
-            (i - l[i]) * (r[i] - i) for i, v in enumerate(nums) if left <= v <= right
-        )
+        def f(x):
+            cnt = t = 0
+            for v in nums:
+                t = 0 if v > x else t + 1
+                cnt += t
+            return cnt
+
+        return f(right) - f(left - 1)