【力扣】连续子数组和，子数组乘积

最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入：nums = [1]
输出：1

class Solution {
    public int maxSubArray(int[] nums) {
  int n = nums.length;
        if(n<0){
            return 0;
        }
        if(n == 1){
            return nums[0];
        }
        int[] dp = new int[n];
        dp[0] = nums[0];
        for(int i = 1;i < n; i++){
            dp[i] = Math.max(nums[i] , nums[i]+dp[i-1]);
        }
        int res = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            res = Math.max(res,dp[i]);
        }
        return res;
    }
}

动态规划，dp数组含义是以i结尾的连续数组最大的和，每一次都有两种选择，一种是元素只取当前元素，一种是前面的dp[i-1]加当前元素。

乘积最大子数组

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

测试用例的答案是一个 32-位 整数。

子数组 是数组的连续子序列。
示例 1:
输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
示例 2:
输入: nums = [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。
暴力递归,保存结果

    public int maxProduct(int[] nums) {
        int n = nums.length;
        int temp = 0;
        int res = Integer.MIN_VALUE;
        for(int i = 0; i<n;i++){
            temp = nums[i];
//            res = Math.max(res,temp); 不然单一元素返回为最小值不走下面循环
            for(int j = i+1; j<n;j++){
                temp *= nums[j];
                res = Math.max(res,temp);
            }
        }
        return res;

    }

class Solution {
public int maxProduct(int[] nums) {
        int n = nums.length;
        int[] dp1 = new int[n];
        int[] dp2 = new int[n];
        dp1[0] = nums[0];
        dp2[0] = nums[0];

        for(int i = 1; i < n; i++){
            dp1[i] = min(dp1[i - 1] * nums[i], dp2[i - 1] * nums[i], nums[i]);
            dp2[i] = max(dp1[i - 1] * nums[i], dp2[i - 1] * nums[i], nums[i]);
        }
        int res = Integer.MIN_VALUE;
        for(int i = 0; i < n; i++){
            res = Math.max(res,dp2[i]);
        }
        return res;

    }
    int min(int a, int b, int c) {
        return Math.min(Math.min(a, b), c);
    }

    int max(int a, int b, int c) {
        return Math.max(Math.max(a, b), c);
    }
}

因为包含负数，所以存一个最小值，存一个最大值，如果往里面加入元素有三种情况，1.本身，2.前一个最大值乘以当前元素，3.前一个最小值乘以当前元素。