文章目录
前言
本题与 力扣713题 相同
题目：乘积小于 K 的子数组
给你一个整数数组 nums 和一个整数 k ，请你返回子数组内所有元素的乘积严格小于 k 的连续子数组的数目。
示例 1：
输入：nums = [10,5,2,6], k = 100
输出：8
解释：8 个乘积小于 100 的子数组分别为：[10]、[5]、[2]、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。
示例 2：输入：nums = [1,2,3], k = 0
输出：0
提示:1 <= nums.length <= 3 * 104
1 <= nums[i] <= 1000
0 <= k <= 106
参考思路
方法一：滑动窗口
注意！！这里的数字都是正数
联想之前的滑动窗口，如果满足非负数组的单调性
- 也就是在非负数组中，子数组和随着窗口的扩展（右边界右移）是单调不减的
参考深入思考中的滑动窗口解析：【算法】力扣560题：和为 K 的连续子数组之深入思考
那么使用滑动窗口是非常好的办法！
- 使用滑动窗口来维护一个满足条件的子数组范围 [left, right]。
- 对于每个右边界 right，找到最小的左边界 left，使得窗口内的乘积小于 k。
- 统计以 nums[right] 结尾的满足条件的子数组个数：right - left + 1。
但是要注意处理极端情况：if (k <= 1) return 0;
复杂度分析
-
时间复杂度：O(n)
每个元素最多被访问两次（一次加入窗口，一次移出窗口）。
-
空间复杂度：O(1)
只使用了常数级别的额外空间。
方法二：二分查找
如果有做过 和为k的子数组 这个题，可能会延伸思考，那么这题如果求乘积。那么我能不能也有前缀乘积的方法来解题呢？
可以！但是仔细一想前缀乘积会使得数字变得很大，从而溢出
所以我们对于数组中的每个元素 nums[i]，取自然对数 ln(nums[i])。
乘积小于 k 的条件可以转换为：
cpp
nums[left] * nums[left+1] * ... * nums[right] < k两边取对数之后
cpp
ln(nums[left]) + ln(nums[left+1]) + ... + ln(nums[right]) < ln(k)此时一看，这不是我们熟悉的前缀和 吗？
因此计算对数数组的前缀和
cpp
prefixSum[i] = ln(nums[0]) + ln(nums[1]) + ... + ln(nums[i-1])对其变形
对于每个右边界 right，我们需要找到最小的左边界 left，使得：
cpp
prefixSum[right+1] - prefixSum[left] < ln(k)之后，问题就转换成了找到一某一个 prefixSum 使其值 < ln(k)
所以核心就是：两边取对数将乘积问题转换为求和问题，然后利用前缀和 + 二分查找来解决
那么注意到数组的数字都是大于1的数字
所以计算前缀和数组是单调递增的，因此可以使用二分查找 来高效地找到满足条件的 left。
这里可以选择直接调用库函数来实现二分查找，只需要快速找到第一个大于等于 ln(k)的位置即可
此时，可能有疑问
1.之前那题"子数组和为k"不是说不能用二分法吗？为什么这里又可以用？
2.那这里这题可以用哈希表优化来做吗？
参考答案可以看本文的第三部分：深入思考
复杂度分析
-
时间复杂度：O(n log n)
计算前缀乘积的时间复杂度是 O(n)。
对于每个 j，二分查找的时间复杂度是 O(log n)，总共有 n 个 j，因此二分查找的总时间复杂度是 O(n log n)。
-
空间复杂度：O(n)
需要存储前缀乘积数组。
二分法可以用来解决乘积小于 K 的子数组问题，但它的时间复杂度是 O(n log n)，不如滑动窗口方法高效
参考题解
方法一：滑动窗口解法
dart
class Solution {
public:
int numSubarrayProductLessThanK(vector<int>& nums, int k) {
if (k <= 1) return 0;
int result = 0;
int left = 0;
int product = 1;
for (int right = 0; right < nums.size(); ++right) {
product *= nums[right];
while (product >= k && left <= right) {
product /= nums[left];
++left;
}
result += right - left + 1;
}
return result;
}
};方法二：二分查找解法
cpp
class Solution {
public:
int numSubarrayProductLessThanK(vector<int>& nums, int k) {
if (k <= 1) return 0;
int n = nums.size();
vector<double> logPrefix(n + 1, 0.0);
double logK = log(k); // ln(k)
for (int i = 0; i < n; ++i) {
logPrefix[i + 1] = logPrefix[i] + log(nums[i]);
}
int count = 0;
// 对于每个右边界 right，使用二分查找找到最小的 left
for (int right = 0; right < n; ++right) {
// 找到第一个大于等于 target 的位置
int left = upper_bound(logPrefix.begin(), logPrefix.begin() + right + 1, logPrefix[right + 1] - logK + 1e-10) - logPrefix.begin();
count += right + 1 - left;
}
return count;
}
};深入思考
浮点精度？
在二分查找中，我们比较的是浮点数（prefixSum[mid] 和 target）。
由于浮点数的精度有限，直接比较可能会导致结果不准确。
例如，prefixSum[mid] 可能非常接近 target，但由于精度问题，prefixSum[mid] >= target 的判断可能会出错。
修正方法：
在比较时，添加一个很小的值（例如 1e-10）来避免浮点数精度问题。
这样可以确保 prefixSum[mid] 和 target 的比较更加准确。
right - left + 1？
为什么最后求解的答案是 right - left + 1？
为什么子数组个数是 right - left + 1？
由于子数组必须是连续的，因此以 nums[right] 结尾的子数组可以表示为：
cpp
[left, right], [left+1, right], [left+2, right], ..., [right, right]简而言之，就是当在遍历左右边界的时候，子数组的个数是right - left + 1。表示以 nums[right] 结尾的满足条件的子数组个数。
right - left 表示从 left 到 right 之间的元素个数（不包括 left）。
- +1 表示包括 left 本身。
- 因此，right - left + 1 表示从 left 到 right 的所有子数组的个数
二分法？
首先思考这题为什么可以用二分法去查找
因为数组数字都是大于或等于 1 ，因此取对数后的前缀和数组是单调递增的，也就是越乘肯定是越大的
所以说可以使用二分法去快速查找
哈希优化？
这题可以效仿【算法】力扣560题：和为 K 的连续子数组之深入思考 使用哈希优化吗？
需要注意的是，哈希表方法通常用于解决"等于某个值"的问题
哈希表通常用于解决以下类型的问题：
- 查找"等于某个值"的情况：例如，求和等于 k 的子数组。
- 快速查找和更新：哈希表可以在 O(1) 时间内完成查找和更新操作。
在求和等于 K 的子数组问题中，哈希表的作用是记录前缀和的出现次数，从而快速判断是否存在子数组的和等于 k。具体来说：
- 对于当前前缀和 sum，我们查找 sum - k 是否在哈希表中。
- 如果存在，则说明存在若干个子数组的和等于 k。
而对于这道题：
在乘积小于 K 的子数组问题中，我们需要找到满足以下条件的子数组：
cpp
nums[left] * nums[left+1] * ... * nums[right] < k取对数后：
cpp
ln(nums[left]) + ln(nums[left+1]) + ... + ln(nums[right]) < ln(k)哈希表的核心功能是快速查找"等于某个值"的情况，而"小于"条件需要遍历哈希表中的所有键值对，时间复杂度会从 O(1) 退化为 O(n)。
例如，对于每个右边界 right，我们需要找到所有满足 prefixSum[left] > prefixSum[right+1] - ln(k) 的 left，这需要遍历哈希表中的所有前缀和。