民营互联网的蛀虫
这几天国内互联网最大的新闻，是杭州某电商公司出的巨型蛀虫。
该员工在公司里职级不高，但却掌握核心权力：审批家具类的开店资格。
身处互联网的他，自然懂得什么叫「裂变」。
为了实现利益最大化，他不断发展"下线"，一家店的开店资格收 30W，合计搞了 400 多家，"营收" 1.3 亿，其中 4000W 分给了下线们，自己含泪留下 9000W。
这钱到手了自然是不敢存银行，于是他拿了 3000W 去炒股，截止事发落网时，损掉了 900W（亏损超 30%），剩下的则是给了朋友帮忙买实物黄金。
按理说，受「美联储降息在即，地缘形势紧张」等影响，黄金最近走势不错，屡创新高，填回股票的损失应该完全不在话下，结果代买黄金的朋友拿了钱去还债，买来的都是忽悠他的"假黄金" 🤣🤣
这剧情发展是真够节目效果的。
笑完小虫的既贪又蠢之后，作为那家电商公司的 mini 股东，不禁担心一个问题：连一个职级不高的人，都能贪近 1 亿的钱（去年这家公司合并净利润为 700 亿出头），这公司里还有多少只看不到的手在拿钱？
再看了一眼股价，脚踝斩了已经，我自己没有浮亏多，但也实在不好意思再伤害大量深套的网友，只能说句：没事，至少反腐已在路上，会好起来的。
对于「一家创办不足 30 年的民营互联网，普通职员受贿 9000W」这事儿，你怎么看？
...
回归主线。
来一道和「阿里巴巴」相关的算法原题。
题目描述
平台：LeetCode
题号：795
给你一个整数数组 nums 和两个整数：left 及 right 。
找出 nums 中连续、非空且其中最大元素在范围 内的子数组，并返回满足条件的子数组的个数。
生成的测试用例保证结果符合 32-bit 整数范围。
示例 1：
输入：nums = [2,1,4,3], left = 2, right = 3
输出：3
解释：满足条件的三个子数组：[2], [2, 1], [3]
示例 2：
输入：nums = [2,9,2,5,6], left = 2, right = 8
输出：7
提示：
单调栈
为了方便，我们令 为 。
一个容易想到的思路是使用「单调栈」。
「统计所有最大值范围在 之间的子数组个数，可等价为统计每一个范围落在 之间的 作为最大值时子数组的个数。」
由此可以进一步将问题转换为：求解每个 作为子数组最大值时，最远的合法左右端点的位置。也就是求解每一个 左右最近一个比其“大”的位置，这可以使用「单调栈」来进行求解。
❝对于单调栈不了解的同学，可以看前置 🧀 : 【RMQ 专题】关于 RMQ 的若干解法
❞
「统计所有 对答案的贡献即是最终答案，但我们忽略了「当 nums 存在重复元素，且该元素作为子数组最大值时，最远左右端点的边界越过重复元素时，导致重复统计子数组」的问题。」
我们不失一般性的举个 🌰 来理解（下图）：
为了消除这种重复统计，我们可以将「最远左右边界」的一端，从「严格小于」调整为「小于等于」，从而实现半开半闭的效果。
Java 代码：
class Solution {
public int numSubarrayBoundedMax(int[] nums, int a, int b) {
int n = nums.length, ans = 0;
int[] l = new int[n + 10], r = new int[n + 10];
Arrays.fill(l, -1); Arrays.fill(r, n);
Deque<Integer> d = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
while (!d.isEmpty() && nums[d.peekLast()] < nums[i]) r[d.pollLast()] = i;
d.addLast(i);
}
d.clear();
for (int i = n - 1; i >= 0; i--) {
while (!d.isEmpty() && nums[d.peekLast()] <= nums[i]) l[d.pollLast()] = i;
d.addLast(i);
}
for (int i = 0; i < n; i++) {
if (nums[i] < a || nums[i] > b) continue;
ans += (i - l[i]) * (r[i] - i);
}
return ans;
}
}
C++ 代码：
class Solution {
public:
int numSubarrayBoundedMax(vector<int>& nums, int a, int b) {
int n = nums.size(), ans = 0;
vector<int> l(n + 10, -1), r(n + 10, n);
deque<int> d;
for (int i = 0; i < n; i++) {
while (!d.empty() && nums[d.back()] < nums[i]) {
r[d.back()] = i;
d.pop_back();
}
d.push_back(i);
}
d.clear();
for (int i = n - 1; i >= 0; i--) {
while (!d.empty() && nums[d.back()] <= nums[i]) {
l[d.back()] = i;
d.pop_back();
}
d.push_back(i);
}
for (int i = 0; i < n; i++) {
if (nums[i] < a || nums[i] > b) continue;
ans += (i - l[i]) * (r[i] - i);
}
return ans;
}
};
Python3 代码：
class Solution:
def numSubarrayBoundedMax(self, nums: List[int], a: int, b: int) -> int:
n, ans = len(nums), 0
l, r = [-1] * n, [n] * n
stk = []
for i in range(n):
while stk and nums[stk[-1]] < nums[i]:
r[stk.pop()] = i
stk.append(i)
stk = []
for i in range(n - 1, -1, -1):
while stk and nums[stk[-1]] <= nums[i]:
l[stk.pop()] = i
stk.append(i)
for i in range(n):
if a <= nums[i] <= b:
ans += (i - l[i]) * (r[i] - i)
return ans
TypeScript 代码：
function numSubarrayBoundedMax(nums: number[], a: number, b: number): number {
let n = nums.length, ans = 0
const l = new Array<number>(n).fill(-1), r = new Array<number>(n).fill(n)
let stk = new Array<number>()
for (let i = 0; i < n; i++) {
while (stk.length > 0 && nums[stk[stk.length - 1]] < nums[i]) r[stk.pop()] = i
stk.push(i)
}
stk = new Array<number>()
for (let i = n - 1; i >= 0; i--) {
while (stk.length > 0 && nums[stk[stk.length - 1]] <= nums[i]) l[stk.pop()] = i
stk.push(i)
}
for (let i = 0; i < n; i++) {
if (nums[i] < a || nums[i] > b) continue
ans += (i - l[i]) * (r[i] - i)
}
return ans
}
-
时间复杂度： -
空间复杂度：
模拟
除了统计「每个 作为子数组最大值时，所能贡献的子数组个数」以外，我们还可以统计「每个 作为子数组右端点时，所能贡献的子数组个数」。
具体的，我们从前往后处理每个 ，并统计其作为子数组右端点时，所能贡献的子数组个数。同时使用变量 j 和 k 分别记录最近一次满足「 范围落在 之间」以及「 数值大于 」的下标位置。
遍历过程中根据 与规定范围 之间的关系进行分情况讨论：
-
大于 ， 作为右端点，必不可能贡献合法子数组。更新 k； -
小于 ，此时 想作为右端点的话，子数组必须有其他满足「范围落在 之间」的其他数，而最近一个满足要求的位置为 ，若有 ，说明范围在 均能作为子数组的左端点，累加方案数 ；若有 ，说明我们无法找到任何一个左端点，使得形成的子数组满足要求（要么最值不在 范围内，要么有 范围内的数，但最大值又大于 b值）； -
落在范围 ，此时 想作为右端点的话，只需要找到左边第一个数值大于 的数值即可（即变量 k），累加方案数 。更新j。
Java 代码：
class Solution {
public int numSubarrayBoundedMax(int[] nums, int a, int b) {
int n = nums.length, ans = 0;
for (int i = 0, j = -1, k = -1; i < n; i++) {
if (nums[i] > b) {
k = i;
} else {
if (nums[i] < a) {
if (j > k) ans += j - k;
} else {
ans += i - k;
j = i;
}
}
}
return ans;
}
}
C++ 代码：
class Solution {
public:
int numSubarrayBoundedMax(vector<int>& nums, int a, int b) {
int n = nums.size(), ans = 0;
for (int i = 0, j = -1, k = -1; i < n; i++) {
if (nums[i] > b) {
k = i;
} else {
if (nums[i] < a) {
if (j > k) ans += j - k;
} else {
ans += i - k;
j = i;
}
}
}
return ans;
}
};
Python3 代码：
class Solution:
def numSubarrayBoundedMax(self, nums: List[int], a: int, b: int) -> int:
n, ans = len(nums), 0
j, k = -1, -1
for i in range(n):
if nums[i] > b:
k = i
else:
if nums[i] < a:
ans += j - k if j > k else 0
else:
ans += i - k
j = i
return ans
TypeScript 代码：
function numSubarrayBoundedMax(nums: number[], a: number, b: number): number {
let n = nums.length, ans = 0
for (let i = 0, j = -1, k = -1; i < n; i++) {
if (nums[i] > b) {
k = i
} else {
if (nums[i] < a) {
if (j > k) ans += j - k
} else {
ans += i - k
j = i
}
}
}
return ans
}
-
时间复杂度： -
空间复杂度：
最后
给大伙通知一下 📢 ：
全网最低价 LeetCode 会员目前仍可用 ~
📅 年度会员：有效期加赠两个月！！; 季度会员：有效期加赠两周！！
🧧 年度会员：获 66.66 现金红包！！; 季度会员：获 22.22 现金红包！！
🎁 年度会员：参与当月丰厚专属实物抽奖（中奖率 > 30%)！！
专属链接：leetcode.cn/premium/?promoChannel=acoier
我是宫水三叶，每天都会分享算法知识，并和大家聊聊近期的所见所闻。
欢迎关注，明天见。
24万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
