【LeetCode】LeetCode之乘积为正数的最长子数组长度——暴力枚举+动态规划+Kadane算法

🔐1.题目描述

给你一个整数数组 nums ，请你求出乘积为正数的最长子数组的长度。
一个数组的子数组是由原数组中零个或者更多个连续数字组成的数组。
请你返回乘积为正数的最长子数组长度。

✨示例 1：

输入：nums = [1,-2,-3,4]
输出：4
解释：数组本身乘积就是正数，值为 24 。

✨示例 2：

输入：nums = [0,1,-2,-3,-4]
输出：3
解释：最长乘积为正数的子数组为 [1,-2,-3] ，乘积为 6 。
注意，我们不能把 0 也包括到子数组中，因为这样乘积为 0 ，不是正数。

✨示例 3：

输入：nums = [-1,-2,-3,0,1]
输出：2
解释：乘积为正数的最长子数组是 [-1,-2] 或者 [-2,-3] 。

✨示例 4：

输入：nums = [-1,2]
输出：1

✨示例 5：

输入：nums = [1,2,3,5,-6,4,0,10]
输出：4

💎提示：

1 <= nums.length <= 10^5
-10^9 <= nums[i] <= 10^9

2.枚举

通过两层for循环，暴力枚举出所有得子数组，然后进行判断即可得到结果；

    /**
     * 枚举
     */
    public int getMaxLen(int[] nums) {
        int size = nums.length;
        int ml = 0;  //最大乘积为正数的最长子数组长度
        int curl = 0; //当前乘积为正数的最长子数组长度
        long curV = 1;	//保存每次乘积之后的数【如果是正数我们直接设置为1，负数为-1，因为数的大小和本体无关，我们只管正负】
        for (int i = 0; i < size; i++) {
            for (int j = i; j < size; j++) {
                curV *= nums[j]; 
                curl++;   //将当前子数组长度++
                if (curV > 0) {
                    curV = 1;//置为1是因为连续乘积数会很大，会超出long范围，所以正数结果置为1即可
                    ml = Math.max(curl, ml);//将当前最长长度与最长长度比较
                } else if (curV == 0) {
                    break; //如果乘积为0，说明当前nums[i]==0，所以需要跳过，因为0不是正数也不是负数
                } else {
                    curV = -1;//如果curV <0 ，乘积置为-1即可，防止乘积数太大
                }
            }
            curl = 0; //每遍历一层，就要重置curl和curV
            curV = 1;
        }
        return ml;
    }

提交到LeetCode发现超时了，这应该也正常吧，毕竟是暴力解法

复杂度分析

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

3.动态规划

动态规划核心三要素：

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

那么怎么分析该问题呢？怎么确定状态呢？
由于本题存在负负得正得情况，所以需要使用两个dp数组保存当前状态，一个是positive(正数）数组，一个是negative(负数）数组；【因为负数乘以负数有可能得到一个更大的值呀】

试想如果要求f(n)的最长子数组长度，是不是分为如下三种情况：

（1） 当nums[i] > 0时

• positive[i] = positive[i - 1] + 1
• negative[i] = negative[i - 1] == 0 ? 0 : negative[i - 1] + 1
  只所以要考虑negative[i - 1]==0的情况，是因为我们需要求最长子数组乘积为负数的长度，而negative[i - 1]一旦为0，又由于当前nums[i]为正数，所以不可能形成负数的情况。

（2） 当nums[i] == 0时

• positive[i] = negative[i] = 0

（3）当nums[i] < 0时

• positive[i] negative[i] == 0 ? 0 : positive[i] + 1
• negative[i] = positive[i] + 1

    /**
     *  动态规划
     */
    public int getMaxLen3(int[] nums) {
        int size = nums.length;
        int[] pos = new int[size];
        int[] neg = new int[size];
        pos[0] = nums[0] > 0 ? 1 : 0;
        neg[0] = nums[0] < 0 ? 1 : 0;
        int ml = pos[0];
        for (int i = 1; i < size; i++) {
            if (nums[i] > 0) {
                pos[i] = pos[i - 1] + 1;
                neg[i] = neg[i - 1] == 0 ? 0 : neg[i - 1] + 1;
            } else if (nums[i] == 0) {
                pos[i] = neg[i] = 0;
            }else {
                pos[i] = neg[i - 1] == 0 ? 0 : neg[i - 1] + 1;
                neg[i] = pos[i - 1] + 1;
            }
            ml = Math.max(ml, pos[i]);
        }
        return ml;
    }

提交到LeetCode自然能通过！

复杂度分析：

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

能不能将空间复杂度优化到O(1)呢？

3.Kadane算法

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

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

 public int getMaxLen4(int[] nums) {
        int size = nums.length;
        int pos = nums[0] > 0 ? 1 : 0;
        int neg = nums[0] < 0 ? 1 : 0;
        int ml = pos;
        for (int i = 1; i < size; i++) {
            if (nums[i] > 0) {
                pos = pos + 1;
                neg = neg == 0 ? 0 : neg + 1;
            } else if (nums[i] == 0) {
                pos = neg = 0;
            } else {
                int temp = pos;
                pos = neg == 0 ? 0 : neg + 1;
                neg = temp + 1;
            }
            ml = Math.max(ml, pos);
        }
        return ml;
    }

复杂度分析：

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