【LeetCode】LeetCode之乘积最大子数组——枚举+动态规划+Kadane算法

🔏1.题目描述

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

📜示例 1:

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

📜示例 2:

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

🍀2.暴力解法

该题最简单的无非就是暴力解法，通过两次for循环枚举出所有子数组，然后维护一个最大值即可。

    /**
     * 暴力解法
     * 时间复杂度:O(n^2)
     * 空间复杂度:O(1)
     */
    public int maxProduct(int[] nums) {
        int maxProduct = nums[0];
        int size = nums.length;
        int curProduct = 1;
        for (int i = 0; i < size; i++) {
            for (int j = i; j < size; j++) {
                curProduct = curProduct * nums[j];
                maxProduct = Math.max(curProduct, maxProduct);
            }
            curProduct = 1;
        }
        return maxProduct;
    }

复杂度分析

时间复杂度：O(n^2)
空间复杂度：O(n)

提交到LeetCode擦边界通过了，本以为时间复杂度O(n^2）一般来说很难通过。

🍀3.动态规划

动态规划核心三要素：

• 阶段：分解子问题，子问题与原问题求解过程相同
• 状态：每个阶段都有一个或多个状态
• 决策：根据当前的决策，确定下一阶段的状态

那么怎么分析该问题呢？如果让你求f(n)，你觉得这个f(n）是怎么从推导过来的？
因为该题存在负负得正的情况，所以这种情况也要考虑；试想如果要求f(n)的乘积最大，是不是分为如下三种情况：

• 如果当前元素a为正数，那么如果要求f(n)最大，是不是只要确保f(n-1)最大即可
  如果当前元素a为负数，那么如果要求f(n)最大，是不是只要保证f(n-1）最小即可，【(-3 * -10 = 30) ( -3 * -100 = 300)
  第三种可能就是正负不一致，那最大值就是a

所以它的递推关系式就是

Fmax(i) = max{Fmax(i-1)*a,Fmin(i-1)*a, a}
Fmin(i) = max{Fmax(i-1)*a, Fmin(i - 1)*a, a}

所以需要两个dp数组进行维护。

    /**
     * 动态规划
     * 时间复杂度:O(n)
     * 空间复杂度:O(n)
     */
    public int maxProduct2(int[] nums) {
        int size = nums.length;
        int[] maxDP = new int[nums.length];
        int[] minDP = new int[nums.length];
        int mp = nums[0];
        maxDP[0] = minDP[0] = mp;
        for (int i = 1; i < size; i++) {
            maxDP[i] = Math.max(Math.max(maxDP[i - 1] * nums[i], minDP[i - 1] * nums[i]), nums[i]);
            minDP[i] = Math.min(Math.min(maxDP[i - 1] * nums[i], minDP[i - 1] * nums[i]), nums[i]);
            mp = Math.max(mp, maxDP[i]);
        }
        return mp;
    }

复杂度分析：

• 时间复杂度:O(n)
• 空间复杂度:O(n)

提交到LeetCode

那么有没有什么办法将空间优化到O(1)呢？

🍀3.Kadane算法

其实本质上Kadane算法还是使用的是动态规划思想，说白了它就是将动态规划的空间复杂度优化到了O(1)，本质上就是动态规划。

上述动态规划是使用两个dp数组作为记忆集的，我们会发现每次求解出的当前状态的结果只会被下次使用一次。所以可以通过变量每次保存当前阶段的结果，然后当求解出下一阶段的结果时，会使用该变量一次，最后计算出了下一阶段得结果，最后赋值给我当前变量即可。循环使用！

    /**
     * Kadane算法【动态规划优化空间】
     * 时间复杂度:O(n)
     * 空间复杂度:O(1)
     */
    public int maxProduct3(int[] nums) {
        int size = nums.length;
        int mp = nums[0];
        int curMax1, curMin1;
        curMax1 = curMin1 = mp;
        for (int i = 1; i < size; i++) {
            int cur = curMax1;
            curMax1 = Math.max(Math.max(curMax1 * nums[i], curMin1 * nums[i]), nums[i]);
            curMin1 = Math.min(Math.min(cur * nums[i], curMin1 * nums[i]), nums[i]);
            mp = Math.max(mp, curMax1);
        }
        return mp;
    }

复杂度分析：

• 时间复杂度:O(n)
• 空间复杂度:O(1)