Leetcode53 连续子数组的最大和

题目描述

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为 O(n).

 示例

输入

[1,-2,3,10,-4,7,2,-5]

输出

18

一般解法

思路分析

1、对于数组array，从array[1]开始逐个进行相加，与最大值比较，并不停地更替最大值

代码实现如下：

public static int findMaxSum(int[] nums) {
    if(nums == null || nums.length <= 0){
        return 0;
    }
    int maxSum = nums[0];
    int curSum = nums[0];
    for(int i = 1; i < nums.length;i++){
        if(curSum <= 0){
            curSum = nums[i];
        }
        else{
            curSum += nums[i];
        }
        if(curSum > maxSum)
            maxSum = curSum;
    }
    return maxSum;
}

思路二：

使用动态规划的思想来分析这个问题,

1、状态方程 ： max( dp[ i ] ) = getMax( max( dp[ i -1 ] ) + arr[ i ] ,arr[ i ] )

2、上面式子的意义是：我们从头开始遍历数组，遍历到数组元素 arr[ i ] 时，连续的最大的和 可能为 max( dp[ i -1 ] ) + arr[ i ] ，也可能为 arr[ i ] ，做比较即可得出哪个更大，取最大值。时间复杂度为 n。

public int FindGreatestSumOfSubArray(int[] array) {
        int[] dp = new int[array.length];
        int max = array[0];
        dp[0] = array[0];
        for(int i=1;i<array.length;i++){
            // 动态规划，状态转移方程，确定dp[i]的最大值
            dp[i] = Math.max(dp[i-1] + array[i], array[i]);
            // 每次比较，保存出现的最大值
            max = Math.max(max,dp[i]);
        }
        return max;
    }

我们可以简化动态规划，使用一个变量sum来表示当前连续的子数组和，以及一个变量max来表示中间出现的最大的和。 

代码如下：

public static int findMaxSum(int[] nums) {
    int max = nums[0];
    int sum = nums[0];
    for(int i = 1; i < nums.length;i++){
        sum = Math.max(sum + nums[i], nums[i]);
        if(sum > max)
            max = sum;
    }
    return max;
}

变形题目：

本题思路：采用动态规划的方法进行求解，找到最优子函数f(n)=max(f(n-1)*m(n),m（n）),其中f（n）代表前n的数中最大值，m(n)代表第n个数的值，在这里还需要考虑到负数，所以还需要找到最小值，因为最小值负数乘以负数可能成为最大值。

步骤一：设置最小值min 和最大值max初始值。

步骤二：遍历数组，比较当前值和当前值乘以最小值以及当前值乘以最大值；得到新的min，和max，比较max与temp的大小，然后依次遍历数组直到结束，最后输出temp。

代码如下：

 public int maxProduct(int[] nums) {
     int result = nums[0], n_max = 1, n_min = 1;
        for(Integer n: nums) {
            if(n < 0) {
                int temp = n_max;
                n_max = Math.max(n_min * n, n);
                n_min = Math.min(temp * n, n);
            } else {
                n_max = Math.max(n_max * n, n);
                n_min = Math.min(n_min * n, n);
            }
               
            result = Math.max(n_max, result);
        }
        
        return result;
    }