剑指 Offer 42. 连续子数组的最大和——动态规划详细解题思路

一、题目

• 输入一个整型数组，数组里有正数也有负数。数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。

• 要求时间复杂度为O(n)。

• 示例1:
  输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
  输出: 6
  解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

• 提示：

  1 <= arr.length <= 10^5
  -100 <= arr[i] <= 100
  注意：本题与主站 53 题相同

• 来源：力扣（LeetCode）
  链接：剑指 Offer 42. 连续子数组的最大和

二、分析

• 【动态规划】
  本题属于动态规划，动态规划的理解和刷题框架可以参考之前的文章
  动态规划_图文详解_Java代码_leetcode刷题模板
  什么是动态规划（Dynamic Programming）？动态规划的意义是什么？(1)
  什么是动态规划（Dynamic Programming）？动态规划的意义是什么？(2)

• 1.能不能使用动态规划
  一个问题能不能动态规划 有以下三点

  • 1.重叠子结构：一个大的问题能否拆成若干小问题
  • 2.满足无后效性： 历史状态不会影响将来的状态，未来的状态和历史无关，当前状态 决定历史状态。
  • 3.最优子结构： 问题的最优解 可否有子问题的最优解推出

• 2.如何使用动态规划

  • dp三连

    • 1.我是谁？ 状态设计

    • 2.我从哪里来 我到哪里去 状态转移

        我从哪里来 代表pull类型的转移  (由顶至底)
        我到哪里去 代表pushl类型的转移 (由底至顶)
        这两个问题在实际求解 考虑清楚一个就行了
      

    • 3.明确初始条件。base case

• 3 问题分析
  求所有子数组的和的最大值

  => 假设 数组长度 为n  求长度为n的所有子数组的和的最大值   
  =>  可以先求 前 n -1 所有子数组的和的最大者 再与 n 比较
  => 问题可以拆分成 若干重叠子问题  
  =>**满足重叠子结构**
  
  => 我只关心 n-1的所有子序列的和 的到n的子数组和，而不必关系 n-1 以前的是怎么求得的 。
     n-1当前状态 ， n未来状态， n-1 以前的是历史状态。 
     n-1以前的历史状态不影响n的未来状态，当前状态 n-1 可以推出未来状态     n-1 =>n 。
  => **满足无后效性*
  
  =>子问题的最大值 可以得到 原问题的最大值 
  => **满足最优子结构**
  
  => **综上 可以使用动态规划**
  

• 4.算法设计

  1.我是谁 -> 状态设计
  
      设 f(i) 是以下标i结尾的所有子数组的和的最大值
  
  2.我到哪里去
      f(i+1) = nums[i+1]          ,f(i) <0
             = f(i) + nums[i+1] ,f(i) >0
      
      即动态转移方程
      dp[i+1] = nums[i+1]  ,dp[i] <0
              = nums[i+1] + dp[i] , dp[i] >=0
  3.明确初始值
    f(0) = nums[0] 只有一个 就是nums[0]
  

三、题解

• 1. [标准dp解法]

  class Solution {
      public int maxSubArray(int[] nums) {
  		//创建dp
          int[] dp = new int[nums.length];
          
          //明确初始条件
          dp[0]=nums[0];
          //我是谁  上面已经分析了，代码中不用体现
          
          //我到哪里去 
          for(int i = 1 ; i < nums.length ; i++){
              
              dp[i] = (dp[i-1]< 0)? nums[i] :dp[i-1] + nums[i];
  
          }
          // 返回结果  遍历dp[] 获取最大值
          int max = Integer.MIN_VALUE;
          for(int i = 0 ; i < dp.length; i ++){
               if(dp[i] > max) max=dp[i];
          }
          return max;
       }
  }
  

• 2.【bp 优化一 】 主要针对获取最大值的优化 不用最后再遍历dp获取最大值

  class Solution {
  	public int maxSubArray(int[] nums) {
          //1.明确初始条件
          int[] dp = new int[nums.length];
  
          dp[0] = nums[0];
  
          //2.我是谁  dp[i]代表以下标为i的数组nums[i]结尾的所有子序列的和的最大值
  
          //3.我从哪里来
          int max = dp[0];
  
          for(int i = 1 ; i < nums.length ; i++){
  
          	dp[i] = (dp[i-1]<0)? nums[i]: dp[i-1]+nums[i];
  
          	max = Math.max(max,dp[i]);
           }
  
          // //4返回
           return max;
  	}
  }
  
  

• 3.【bp 优化二】 如果允许修改原数组，直接用原数组 当做dp[]

  //动态规划一般都有两种优化的方法 ： 
  //①滚动数组 ： 如果题目允许我们修改原数组 我们直接使用原数组当做dp数组。避免重新创建一个dp  可以将空间复杂度将为O(1)
  //②变量替换 ： 如果不允许修改原数组，且我们发现 dp[i] 只与 dp[i-1 或者前几个dp值有关，我们可以创建对应数量数的变量 不断交替更新即可，不用创建整个dp
  
  
  //滚动数组： 直接用原数组当做dp数组
  public int maxSubArray(int[] nums) {
  
      //特例处理
      int len = nums.length;
      if(nums == null || len == 0) return 0;
  
      int max = nums[0];
  
      //使用原数组当做dp数组
      for(int i = 1 ; i < len; i++){
          nums[i] = (nums[i-1] < 0)? nums[i] : nums[i-1]+nums[i];
          max = Math.max(max,nums[i]);
      }
      return max;
  }
  
  
  //变量替换： dp状态方程中，dp[i] 只和dp[i-1]相关，我们可以定义一个变量 并不断的更新它，达到dp数组的效果
  public int maxSubArray(int[] nums) {
      //特例处理
      int len = nums.length;
      if(nums == null || len == 0) return 0;
  
      int max = nums[0];
      int sum = 0; // 替换dp列表
  
      for(int i = 0; i < len; i++){
  
          sum =  sum < 0? nums[i] : nums[i]+sum; //在第一次的时候，sum是替换dp[i-1] 计算后更新为dp[i]
          max = Math.max(sum,max);
      }
      return max;
  
  }
  

}

```