leetcode hot100 之 乘积最大子数组

题目

给定一个整型数组。找出最大乘积的连续子数组，返回其乘积。结果是一个 int 32 位数字。

输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

原题链接：https://leetcode.cn/problems/maximum-product-subarray/

思路

思路1

双指针滑窗法。
首先连续子数组肯定不能包含0 ，因为 0 乘任何数都为 0。所以我们可以每次从非 0 的数字开始滑窗。
当我们不断地把非 0 的数字乘到一起，绝对值一定是越来越大的。所以可以在这个过程中不断更新子数组的乘积，并更新最终结果。直到遇到 0 为止。
此时，需要考虑一种情况，就是如果子数组的乘积为负数时，需要缩小窗口，使得乘积为正数。则不断缩小左侧边界，同时将子数组的累乘结果除掉移除的数字。直到乘积为正数为止。

• 复杂度分析
  • 时间复杂度 O(n)。
  • 空间复杂度 O(1)。

思路2

动态规划。
类似于《最大子数组和》。设 dp_max[i] 表示以 i 为结尾的子数组，最大的乘积。
dp_max[i] = max(dp_max[i - 1] * nums[i], nums[i])
在只有非负数的情况下，以上式子成立。
如果考虑负数，如果当前数是负数，则最大数乘上一个负数将变成最小数；而最小数乘上一个负数将变成最大数。所以我们需要记录一个最小的乘积 dp_min[i] 。
当 nums[i] 为负数时，
dp_max[i] = max(dp_min[i - 1] * nums[i], nums[i])

对于 dp_min 的转移方程，也分 nums[i] 正负两种情况考虑，
nums[i] 为正：
dp_min[i] = min(dp_min[i - 1] * nums[i], nums[i])
nums[i] 为负：
dp_min[i] = min(dp_max[i - 1] * nums[i], nums[i])

初始化 dp_max[0] = dp_min[0] = nums[0]

由于 dp[i] 只依赖 dp[i - 1]，可以把空间复杂度优化为常数。

• 复杂度分析
  • 时间复杂度 O(n)。
  • 空间复杂度 O(1)。

代码

代码1

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int i = 0;
        int j = 0;
        int res = INT_MIN;
        while (j < nums.size()) {
            while (j < nums.size() && nums[j] == 0) {
                j++;
                res = max(res, 0);
            }
            i = j;
            int sub_res = 1;
            while (j < nums.size() && nums[j] != 0) {
                sub_res *= nums[j];
                res = max(res, sub_res);
                j++;
            }
            if (sub_res < 0) {
                while (i < j - 1 && sub_res < 0) {
                    sub_res /= nums[i];
                    i++;
                }
                res = max(res, sub_res);
            }
        }
        return res;
    }
};

代码2

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int dp_max = nums[0];
        int dp_min = nums[0];
        int res = nums[0];
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] >= 0) {
                dp_max = max(dp_max * nums[i], nums[i]);
                dp_min = min(dp_min * nums[i], nums[i]);
            }
            else {
                int pre_dp_max = dp_max;
                dp_max = max(dp_min * nums[i], nums[i]);
                dp_min = min(pre_dp_max * nums[i], nums[i]);
            }
            res = max(res, dp_max);
        }
        return res;
    }
};