leetcode 713乘积小于k的子数组

题意

给定一个正整数数组 nums。

找出该数组内乘积小于 k 的连续的子数组的个数。
注意！！！是连续的子数组

题解

当时第一想法是回溯法枚举，一顿写

class Solution {
public:
    int result = 0;
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        backtrack(nums, k, 0, 1);
        return result;
    }
    void backtrack(vector<int>& nums, int k, int index, int temp) {
        if (index == nums.size() && temp < k) {
            result++;
            return;
        }
        if (index == nums.size() && temp >= k)
            return;
        temp *= nums[index];
        backtrack(nums, k, index+1, temp);
        temp /= nums[index];
        backtrack(nums, k, index+1, temp);
    }
};

哦豁，报错，答案不对。把例子手算一遍，原来是连续子数组。。。。直接回溯枚举是行不通了
那想连续就可以一个一个回溯，对每个元素递归。改一下代码：

class Solution {
public:
    int result = 0;
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        for(int i = 0; i < nums.size(); ++i)
            backtrack(nums, k, i, 1);
        return result;
    }
    void backtrack(vector<int> &nums, int k, int index, int temp){
        if(temp >= k || index == nums.size())//这里结束条件改成这样，是因为连续数组必须每个元素都取，没有两种选择了。如果乘积大于k立即停止递归，如果index超出边界，也立即停止，因为在上一次递归种就已经判断了乘积是否小于k
            return;
        if (temp * nums[index] < k)//只要乘积小于k就是一个解，然后继续递归
        result++;
        temp *= nums[index];
        backtrack(nums, k, index+1, temp); 
    }
};

哦豁，报超时，报超时的例子是差不多五位数的重复1。重复数字太多，回溯法递归的栈会很深。好了回溯法彻底被毙掉。

接下来，既然是连续的数组，有一个常考的方法，滑动窗口也就是双指针。尝试一下。
遍历左指针，对每个左指针找一个最小的右指针，使得窗口内乘积小于k

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        int result = 0;
        int temp = 1;
        for (int left = 0; left < nums.size(); left++) {
            int temp = 1;
            int right = left;
            for (; right < nums.size(); right++) {
                if (temp * nums[right] >= k)
                    break;
                else
                    temp *= nums[right];
            }
            result += right - left;
        }
        return result;
    }
};

结果继续在重复1那个测试用例超时。想了想，这样遍历和逐一枚举没有区别，有很多不必要的计算，比如左指针向后移一位时，上一次的计算其实是可以被利用的。比如下标1-5的乘积计算可以由上一次0-5的乘积除以0处的元素值得到，而不需要把右指针从1遍历到5一个一个累乘。因此我们可以遍历右指针，试一下：

class Solution {
public:
    int numSubarrayProductLessThanK(vector<int>& nums, int k) {
        int n = nums.size();
        int result = 0;
        int left = 0;
        int temp = 1;
        for (int right = 0; right < n; ++right)//对每个右指针，在其左侧寻找合适的左指针，这样可以利用上一次计算的结果。当乘积超过k，左指针向后移，直到窗口内乘积小于k
        {
            temp *= nums[r];
            // 一旦超过k则不断移动左指针来减少
            while (temp >= k && l <= r)
            {
                temp /= nums[l];
                ++left;
            }
            result += right - left + 1;
        }
        return result;
    }
};

ac