[TOC]

一、题目描述

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。

示例 1:

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

示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-product-subarray
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题方法

1. 暴力法（超时）

思路：

暴力出奇迹，这是我这种弟弟总是第一时间想到的东西。既然你要乘积最大的连续子序列，我将所有的乘积保存下来，再取最大的岂不简单粗暴？
只要令表示从到的乘积即可，则显然：

当然，不用问的，暴力怎么可能会出得了奇迹？

时间复杂度：，空间复杂度：。

代码：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if (nums.empty())   return 0;

        auto ans = nums[0];
        vector<vector<int>> dp(nums.size(), vector<int>(nums.size(), 0));
        for (auto i = 0; i < nums.size(); ++i) {
            dp[i][i] = nums[i];
            ans = max(ans, nums[i]);
        }
        for (auto diff = 1; diff < nums.size(); ++diff) {
            for (auto i = 0; i + diff < nums.size(); ++i) {
                dp[i][i + diff] = dp[i][i + diff - 1] * nums[i + diff];
                ans = max(ans, dp[i][i + diff]);
            }
        }
        return ans;
    }
};

2. 数学？？？

思路：

既然暴力法没辙了，那我们就稍微分析一下问题吧。

题目说，这是一个整数数组。
相信能做这道题目的人，一定能理解因为是连乘，所以在不考虑的情况下一定是越多的整数相乘，得到的结果的绝对值越大，最后无非是正负的问题。
同样，负负得正，所以如果是偶数个负数的情况，我们只要一股脑全乘起来就好了，一定是最大的。而如果是奇数个负数的情况，要么放弃第一个负数，要么放弃最后一个负数，取二者中能得到的最大乘积。
如果要考虑，由于会将乘积变为，我们可以利用将数组进行分割，在每一个子数组中，利用上述结论即可。

时间复杂度：，空间复杂度：

代码：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if (nums.empty())   return 0;
        
        auto ans = nums[0], product = 1;
        // 从左往右扫描，等价于奇数情况放弃最右边负数
        for (auto i = 0; i < nums.size(); ++i) {
            product *= nums[i];
            ans = ans > product ? ans : product;
            product = product == 0 ? 1 : product;
        }
        product = 1;
        // 从右往左扫描，等价于奇数情况放弃最左边负数
        for (auto i = int(nums.size()) - 1; i > -1; --i) {
            product *= nums[i];
            ans = ans > product ? ans : product;
            product = product == 0 ? 1 : product;
        }
        return ans;
    }
};

3. 动态规划

思路：

这次是真动态规划，不是解法1那个假洋鬼子。

还记得最大子序和这一题吗？它有动态规划的解。这一题跟它好像很类似？只不过一个求和一个求积，或许我们可以采取类似的方法来解这一题？

假如类比过来，我们采用表示到为止的乘积最大值，我们并不能像求和一样令：

因为乘法存在负负得正的情况，哪怕当前是负数，指不准下面扫描到一个负数立马就变成了正的最大值了呢？所以我们必须要能保存已经出现的最小值的情况，同时，因为最大值和最小值可能会互换，我们还需要保存已经出现的最大值的情况。
令、分别表示扫描到为止的最大值和最小值，则我们有：


这里的和可以用来处理掉的情况，否则一旦出现就全完了。

看得出来，由于我们只需要使用到和，所以我们可以将状态压缩到和两个变量，来节约开辟数组的内存。

时间复杂度：，空间复杂度：

代码：

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if (nums.empty())
            return 0;

        auto ans = numeric_limits<int>::min();
        auto pos = 1, neg = 1;
        for (auto &num : nums) {
            if (num < 0)    swap(pos, neg);
            pos = max(pos * num, num);
            neg = min(neg * num, num);
            ans = max(pos, ans);
        }
        return ans;
    }
};