力扣(LeetCode)刷题第152题：乘积最大子数组

---

前言

题目地址：乘积最大子数组

一、分析题目

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。。
示例 1:

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

示例 2:

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

我觉得你如果做的多了，可能一看就看出来了，或者你试着其他的思路是否可以解决这种问题，对于一个题目是否是动态规划的问题，你可以从以下几个方面来看。

动态规划满足三个性质：最优子结构、无后效性和大量重复子问题。
关于这个三个性质的解释，可以参考知乎的这篇文章：怎样学好动态规划？

二、解题思路

1.找出DP状态

我们其实可以发现到达每一个元素的最大乘积都跟到达前一个位置的最大子数组有关系，可以联想到子问题都是这样的，因此可以考虑动态规划的思想来结题。

例如给出nums = [2,-1,-2]，根据上述 f[i] 的定义，我们可以得到 f = [2,-1,4] 。不难发现f[3] = 4!=nums[3]!=f[2]*nums[3]， f[i]的值与 f[i-1]的值无关，即 DP 状态最优值无法由更小规模的 DP 状态最优值推出，因此不符合「最优子结构」原则。

其实是因为每一个位置的数据存在正负的问题，所以这里让我感觉不符合，加上正负的判断即可。

因此需要设置两个DP状态，一个保存到当前位置的乘积最大子数组max[]，一个保存到当前位置的乘积最小子数组min[]。

2.找出DP状态转移方程

确定完「DP 状态」后，继续确定「DP 转移方程」。
「DP 转移方程」：

if(nums[i] > 0) {
    maxn[i] = max(nums[i], maxn[i - 1] * nums[i]);
    minn[i] = min(nums[i], minn[i - 1] * nums[i]);
}
else {
    maxn[i] = max(nums[i], minn[i - 1] * nums[i]);
    minn[i] = min(nums[i], maxn[i - 1] * nums[i]);
}

3.代码部分

1.Java版本

class Solution {
    public int maxProduct(int[] nums) {
        int row = nums.length;
        int []max = new int[row];
        int []min = new int[row];
        int maxF = nums[0];
        System.arraycopy(nums, 0, max, 0, row);
        System.arraycopy(nums, 0, min, 0, row);
        for(int i =1;i<row;i++){
            if(nums[i]>0){
                max[i] = Math.max(nums[i],max[i-1]*nums[i]);
                min[i] = Math.min(nums[i],min[i-1]*nums[i]);
            }
            else{
                max[i] = Math.max(nums[i],min[i-1]*nums[i]);
                min[i] = Math.min(nums[i],max[i-1]*nums[i]);
            }
            maxF = Math.max(maxF,max[i]);
        }
        return maxF; 

    }
}

2.C++版本

class Solution {
public:
    vector<int> maxn, minn;
    int maxProduct(vector<int>& nums) {
        int n = nums.size(), ans = nums[0];
        maxn.resize(n);
        minn.resize(n);
        maxn[0] = minn[0] = nums[0];
        for (int i = 1; i < nums.size(); ++i) {
            if(nums[i] > 0) {
                maxn[i] = max(nums[i], maxn[i - 1] * nums[i]);
                minn[i] = min(nums[i], minn[i - 1] * nums[i]);
            }
            else {
                maxn[i] = max(nums[i], minn[i - 1] * nums[i]);
                minn[i] = min(nums[i], maxn[i - 1] * nums[i]);
            }
            ans = max(ans, maxn[i]);
        }
        return ans;
    }
};

3.代码改进

1.其中的Dp状态转移不一定要区分大小写，每次来的时候用下面的状态转移方程即可。

  maxF[i] = max(maxF[i - 1] * nums[i], max(nums[i], minF[i - 1] * nums[i]));
  minF[i] = min(minF[i - 1] * nums[i], min(nums[i], maxF[i - 1] * nums[i]));

2.另外还可以使用临时变量来保存，由于当前位置的乘积最大子数组只与前一位置的有关，那么可以使用一个变量来代替最大最小数组即可。

int mx = maxF, mn = minF;
maxF = max(mx * nums[i], max(nums[i], mn * nums[i]));
minF = min(mn * nums[i], min(nums[i], mx * nums[i]));
ans = max(maxF, ans);

三、总结

提示：这个题在动态规划里面算一个中等难度的题目，感觉这块内容确实比较让头头大，只能多做题，多总结了。

记录时间：2020年11月24日