【动态规划】 LeetCode #152 乘积最大子数组

题目链接：

LeetCode #152 乘积最大子数组

题目描述：

#152. 乘积最大子数组

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

示例 1:

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

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

通过次数70,288 | 提交次数177,501

分析：

原来做过一个题，是求和最大子数组，所以一开始想的是这个题也设 dp[i] 为以 nums[i] 结尾的连续子数组相乘的最大值，但是在测试时会发现问题：

当两个负数中间夹着正数的时候，计算负数的最大值可能要用到前面的最小值，因为负负得正，如：[-3, 2, -5] 最大值应该是（-3）× 2 ×（-5）= 30。

所以我们要记录的不只是最大值，还要记录最小值。

动态规划，设 dp[i][j] 为以 nums[i] 结尾的连续子数组相乘的最大值和最小值， 即二维数组 dp[][] 只有两行，第一行记录最小值，第二行记录最大值。虽然我们记录了最大值和最小值，但是实际最终要求的是最大值，之所以记录最小值，只是针对两个负数之间有正数的情况，这种情况下最小值可能会摇身一变变为最大值。

状态转移方程式：（以 nums[i] 的正负分类讨论）

若 nums[i] = 0, 则 dp[i][0] = 0, dp[i][1] = 0

若 nums[i] > 0：(当前结尾元素为正数)

先分析最大值：(正数 × 正数才会大，去看上一个的最大值)
当 dp[i - 1][1] > 0 时，dp[i][1] = dp[i - 1][1] * nums[i]
否则，dp[i][1] = nums[i]

再来看最小值：(正数 × 负数才会小，去看上一个的最小值)
当 dp[i - 1][0] <= 0 时，dp[i][0] = dp[i - 1][0] * nums[i]

若 nums[i] < 0：(当前结尾元素为负数)

先分析最大值：（一个负数怎么才能尽可能大？乘上一个负数）
当 dp[i - 1][0] < 0, dp[i][1] = dp[i - 1][0] * nums[i]
否则，dp[i][1] = nums[i]

再来看最小值：
当 dp[i - 1][1] > 0, dp[i][0] = dp[i - 1][1] * nums[i]
否则，dp[i][0] = nums[i]

到此就全部分析完了，接下来把上述情况整理汇总一下：

最大值 dp[i][1] = max(dp[i - 1][0] * nums[i] , dp[i - 1][1] * nums[i], nums[i])

最小值 dp[i][0] = min(dp[i - 1][0] * nums[i], dp[i - 1][1] * nums[i], nums[i])

第一次提交：

提交结果：

代码：

/*
*动态规划，设 dp[i][j] 为以 nums[i] 结尾的连续子数组相乘的最大值和最小值
*即二维数组 dp[][] 只有两行，第一行记录最小值，第二行记录最大值
*虽然我们记录了最大值和最小值，但是实际最终要求的是最大值
*之所以记录最小值，只是针对两个负数之间有正数的情况
*这种情况下最小值可能会摇身一变变为最大值，如：[-3, 2, -5]
*若 nums[i] = 0, 则 dp[i][0] = 0, dp[i][1] = 0
*若 nums[i] > 0, 
*先分析最大值：当 dp[i - 1][1] > 0 时，dp[i][1] = dp[i - 1][1] * nums[i]
*                        否则，dp[i][1] = nums[i]
*再来看最小值：当 dp[i - 1][0] <= 0 时，dp[i][0] = dp[i - 1][0] * nums[i]
*                        否则，dp[i][0] = nums[i] 
*若 nums[i] < 0, 
*先分析最大值：一个负数怎么才能尽可能大？乘上一个负数
*                       当 dp[i - 1][0] < 0, dp[i][1] = dp[i - 1][0] * nums[i]
*                       否则，dp[i][1] = nums[i]
*再来看最小值：当 dp[i - 1][1] > 0, dp[i][0] = dp[i - 1][1] * nums[i]
*                         否则，dp[i][0] = nums[i]
*整理汇总一下：最大值 dp[i][1] = max(dp[i - 1][0] * nums[i] , dp[i - 1][1] * nums[i], nums[i])
*                       最小值 dp[i][0] = min(dp[i - 1][0] * nums[i], dp[i - 1][1] * nums[i], nums[i])  
*/
class Solution {
    public int maxProduct(int[] nums) {
        if(nums.length == 1) return nums[0];
        int result = nums[0];
        int[][] dp = new int[nums.length][2];
        dp[0][0] = dp[0][1] = nums[0];
        for(int i = 1;  i < nums.length; i++){
            dp[i][1] = Math.max(Math.max(dp[i - 1][0] * nums[i] , dp[i - 1][1] * nums[i]), nums[i]);
            dp[i][0] = Math.min(Math.min(dp[i - 1][0] * nums[i], dp[i - 1][1] * nums[i]), nums[i]);
            if(result < dp[i][1]){ result = dp[i][1];}
        }
        return result;
    }
}

优化：

时间复杂度已经是 O(n) 了，用动态规划思想没有可以优化的地方，空间复杂度是 O(n^2)，创建了二维数组 dp[][]，下面就针对空间复杂度进行优化：

每次计算 dp[i][0] 和 dp[i][1] 时，只会用到前一位的最大值和最小值，不必创建二维数组，用 4 个变量即可

第二次提交：(空间复杂度O(1))

先来看提交结果：

以下为优化后的代码：

/*
*动态规划，设 dp[i][j] 为以 nums[i] 结尾的连续子数组相乘的最大值和最小值
*即二维数组 dp[][] 只有两行，第一行记录最小值，第二行记录最大值
*虽然我们记录了最大值和最小值，但是实际最终要求的是最大值
*之所以记录最小值，只是针对两个负数之间有正数的情况
*这种情况下最小值可能会摇身一变变为最大值，如：[-3, 2, -5]
*若 nums[i] = 0, 则 dp[i][0] = 0, dp[i][1] = 0
*若 nums[i] > 0, 
*先分析最大值：当 dp[i - 1][1] > 0 时，dp[i][1] = dp[i - 1][1] * nums[i]
*                        否则，dp[i][1] = nums[i]
*再来看最小值：当 dp[i - 1][0] <= 0 时，dp[i][0] = dp[i - 1][0] * nums[i]
*                        否则，dp[i][0] = nums[i] 
*若 nums[i] < 0, 
*先分析最大值：一个负数怎么才能尽可能大？乘上一个负数
*                       当 dp[i - 1][0] < 0, dp[i][1] = dp[i - 1][0] * nums[i]
*                       否则，dp[i][1] = nums[i]
*再来看最小值：当 dp[i - 1][1] > 0, dp[i][0] = dp[i - 1][1] * nums[i]
*                         否则，dp[i][0] = nums[i]
*整理汇总一下：最大值 dp[i][1] = max(dp[i - 1][0] * nums[i] , dp[i - 1][1] * nums[i], nums[i])
*                       最小值 dp[i][0] = min(dp[i - 1][0] * nums[i], dp[i - 1][1] * nums[i], nums[i])  
*优化：每次计算 dp[i][0] 和 dp[i][1] 时，只会用到前一位的最大值和最小值，不必创建二维数组，用 4 个变量即可
*/
class Solution {
    public int maxProduct(int[] nums) {
        if(nums.length == 1) return nums[0];
        int result = nums[0];
        int preMin = nums[0], preMax = nums[0];//preMin和preMax分别记录上一个的最小值、最大值
        int min = nums[0], max = nums[0];
        for(int i = 1;  i < nums.length; i++){
            max = Math.max(Math.max(preMin * nums[i] , preMax * nums[i]), nums[i]);
            min = Math.min(Math.min(preMin * nums[i], preMax * nums[i]), nums[i]);
            if(result < max){ result = max;}
            preMin = min;
            preMax = max;
        }
        return result;
    }
}

小结：

1 . 不要想到用二维数组 dp[][]就觉得这个方法应该被舍弃，二维数组优化以后也可能变为创建一位数组 dp[]，或者只需要几个变量。

2 . 提交结果里执行用时很长，并不代表这个算法的时间复杂度高，两次提交我们并没有改变时间复杂度，只是对空间复杂度进行了优化，而提交结果中发生显著变化的其实是“执行用时”，从“在所有 Java 提交中击败了 19.43% 的用户”变为了“在所有 Java 提交中击败了 90.51% 的用户”。因为执行用时不仅仅与时间复杂度有关，还包括了创建数组的时间、从数组读数据和从变量读数据等等很多细节上的用时；同理，内存消耗也不仅仅与空间复杂度有关，实际上这些内存消耗往往是被测试用例占了大头。

3 . 这个题还有其他的解法，比如“先计算从左到右的相乘的最大值，再计算从右到左的最大值，再将两组最大值相比”，本文只介绍了动态规划的解法，更多解法可以去最上方题目链接中的“评论”和“题解”里找。