【LeetCode】Day54-乘积最大子数组&乘积为正数的最长子数组长度

题目1

152. 乘积最大子数组【中等】

题解

第一反应是照着昨天的最大子序和来做，but！如果数组是[-2,3,-2]的话，返回结果为3，而正确结果应该为12，是因为出现负数的缘故，然后就没想出来解决办法

题解中给出的做法非常类似于昨天的环形数组子序和，维护一个最大乘积dp_max[]的同时，维护一个最小乘积dp_min[]
如果有负数出现，那么让最后一个负数之前的乘积越小越好（所以需要最小乘积），这样乘上最后一个负数时乘积就最大了

class Solution {
    public int maxProduct(int[] nums) {
        int n=nums.length;
        int[] dp_max=new int[n];
        int[] dp_min=new int[n];
        dp_max[0]=dp_min[0]=nums[0];
        int max=nums[0],min=nums[0];
        for(int i=1;i<n;i++){
            dp_max[i]=Max(dp_max[i-1]*nums[i],dp_min[i-1]*nums[i],nums[i]);
            dp_min[i]=Min(dp_max[i-1]*nums[i],dp_min[i-1]*nums[i],nums[i]);
           
            max=Math.max(max,dp_max[i]);
            min=Math.min(min,dp_min[i]);
        }
        return max;
    }
    //三数最大值
    public int Max(int a,int b,int c){
        int tmp=Math.max(a,b);
        return Math.max(tmp,c);
    }
    //三数最小值
    public int Min(int a,int b,int c){
        int tmp=Math.min(a,b);
        return Math.min(tmp,c);
    }
}

时间复杂度：$O(n)$

空间复杂度：$O(n)$

如果要用O(1)的空间复杂度实现：将dp_max[]，dp_min[]变为整型变量

class Solution {
    public int maxProduct(int[] nums) {
        int n=nums.length;
        int premax=nums[0],premin=nums[0];
        int max=nums[0],min=nums[0];
        for(int i=1;i<n;i++){
            int tmp=premax;
            premax=Max(premax*nums[i],premin*nums[i],nums[i]);
            premin=Min(tmp*nums[i],premin*nums[i],nums[i]);
            
            max=Math.max(max,premax);
            min=Math.min(min,premin);
        }
        return max;
    }
    //三数最大值
    public int Max(int a,int b,int c){
        int tmp=Math.max(a,b);
        return Math.max(tmp,c);
    }
    //三数最小值
    public int Min(int a,int b,int c){
        int tmp=Math.min(a,b);
        return Math.min(tmp,c);
    }
}

题目2

1567. 乘积为正数的最长子数组长度【中等】

题解

定义两个数组 positive 和 negative，其中 pos[i] 表示以下标 i 结尾的乘积为正数的最长子数组长度，neg[i] 表示乘积为负数的最长子数组长度。

最终返回最大的pos[i]

class Solution {
    public int getMaxLen(int[] nums) {
        int n=nums.length;
        int[] pos=new int[n];
        int[] neg=new int[n];
        pos[0]=nums[0]>0?1:0;
        neg[0]=nums[0]<0?1:0;
        
        int max=pos[0];//结果
        for(int i=1;i<n;i++){
            if(nums[i]==0){
                pos[i]=0;
                neg[i]=0;
            }
            else if(nums[i]>0){
                pos[i]=pos[i-1]+1;
                //前面没有负数,乘一个正数也不可能是负数,因此neg[i]为0;否则乘积为负的数组长+1
                neg[i]=neg[i-1]==0?0:neg[i-1]+1;
            }
            else{
                 //前面没有负数,乘一个负数也不可能是正数,因此pos[i]为0;否则乘积为正的数组长+1
                pos[i]=neg[i-1]==0?0:neg[i-1]+1;
                neg[i]=pos[i-1]+1;
            }
            max=Math.max(max,pos[i]);
        }
        return max;
    }
}

时间复杂度：$O(n)$

空间复杂度：$O(n)$

如果要用O(1)的空间复杂度实现：将pos[]，neg[]变为整型变量
（当dp[i]只与dp[i-1]有关时，就可以用这样的滚动数组优化空间）

class Solution {
    public int getMaxLen(int[] nums) {
        int n=nums.length;
        int pos=nums[0]>0?1:0;
        int neg=nums[0]<0?1:0;
        
        int max=pos;//结果
        for(int i=1;i<n;i++){
            if(nums[i]==0){
                pos=0;
                neg=0;
            }
            else if(nums[i]>0){
                pos=pos+1;
                //前面没有负数,乘一个正数也不可能是负数,因此neg[i]为0;否则乘积为负的数组长+1
                neg=neg==0?0:neg+1;
            }
            else{
                int tmp=pos;
                 //前面没有负数,乘一个负数也不可能是正数,因此pos[i]为0;否则乘积为正的数组长+1
                pos=neg==0?0:neg+1;
                neg=tmp+1;
            }
            max=Math.max(max,pos);
        }
        return max;
    }
}