[2021校招必看之Java版《剑指offer》-30] 连续子数组的最大和

1、题目描述

  【JZ30】HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
  知识点：数组
  难度：☆

2、解题思路

2.1 暴力遍历

  对数组的每一个元素进行遍历，当遍历到第i个元素时，我们分别计算array[i]、array[i] + array[i+1]、…、array[i] + array[i+1] + ... + array[array.length-1]，总共有N的阶乘个结果，找出这些结果当中的最大值即可。

2.2 动态规划法

  定义一个数组dp，长度和array一样。
  dp[i]表示：包含array[i]的array的连续子数组的最大和。
  计算方法为：
    当dp[i-1] > 0时，dp[i] = dp[i-1] + array[i]；
    当dp[i-1] < 0时，dp[i] = array[i]。
  原因解释：遍历到array[i]时，dp[i]有两个选择，要么就是加上dp[i-1]，要么是不加dp[i - 1]。如果dp[i-1] > 0，那么加上array[i]，肯定比array[i]大；如果dp[i-1] < 0，则还是就只取array[i]，不然加了之后dp[i]就更小了。
  假设一个数组为array = {1,-2,3,10,-4,7,2,-5}
  i=0时，子数组为{1}，dp[0]=1；
  i=1时，子数组为{1,-2}，dp[1]=-1；
  i=2时，子数组为{1,-2,3}，dp[2]=3；
  i=3时，子数组为{1,-2,3,10}，dp[3]=13；
  i=4时，子数组为{1,-2,3,10,-4}，dp[4]=9；
  i=5时，子数组为{1,-2,3,10,-4,7}，dp[5]=16；
  i=6时，子数组为{1,-2,3,10,-4,7,2}，dp[6]=18；
  i=7时，子数组为{1,-2,3,10,-4,7,2,-5}，dp[7]=13；
  通过分析可知，最大值为18，目标子数组是以array[6]结尾的{3,10,-4,7,2}。

3、解题代码

3.1 暴力遍历

package pers.klb.jzoffer.medium;

/**
 * @program: JzOffer2021
 * @description: 连续子数组的最大和（暴力遍历）
 * @author: Meumax
 * @create: 2020-07-08 14:09
 **/
public class GreatestSumOfSubArray {

    // 子向量的长度至少为1
    public int FindGreatestSumOfSubArray(int[] array) {
        int max = array[0];
        int length = array.length;
        int sum;
        for (int i = 0; i < length; i++) {
            sum = array[i];
            if (max < sum) {
                max = sum;
            }
            for (int j = i + 1; j < length; j++) {
                sum += array[j];
                if (max < sum) {
                    max = sum;
                }
            }
        }
        return max;
    }
}

  时间复杂度：O(N²)
  空间复杂度：O(1)

package pers.klb.jzoffer.medium;

/**
 * @program: JzOffer2021
 * @description: 连续子数组的最大和
 * @author: Meumax
 * @create: 2020-07-08 14:09
 **/
public class GreatestSumOfSubArray {
    
    public int FindGreatestSumOfSubArray(int[] array) {

        int[] dp = new int[array.length];
        dp[0] = array[0];
        int max = dp[0];

        for (int i = 1; i < dp.length; i++) {
            if (dp[i - 1] > 0) {
                dp[i] = dp[i - 1] + array[i];
            } else {
                dp[i] = array[i];
            }
            max = Math.max(max,dp[i]);
        }

        return max;
    }
}

  时间复杂度：O(N)
  空间复杂度：O(N)，创建了一个长度为N的数组dp，可以不创建该数组，直接定义一个变量temp来临时保存dp[i]。

4、解题心得

  暴力遍历是马上能想得到的，对于这种带“连续”条件的，一般可以从动态规划入手，动态规划的难点就在于找出状态方程，而状态方程其实就是找出规模为n时的解和规模为n-1时的解之间的关系。本题的状态方程为：当dp[i-1] > 0时，dp[i] = dp[i-1] + array[i]；当dp[i-1] < 0时，dp[i] = array[i]。分析出这一点，解题就不难了。