剑指 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[]

  class Solution {
  	public int maxSubArray(int[] nums) {
         //1.明确初始条件 dp[0] = nums[0]
         //2.我是谁
         //3.我从哪里来，
         int max = nums[0];
         for(int i = 1 ;  i< nums.length ; i++){
  
             nums[i] = (nums[i-1] < 0 )? nums[i] : nums[i-1]+nums[i];
             //nums[i] = Math.max(nums[i-1],0)  这也是一种思路，将负数置为0
             max = Math.max(max,nums[i]);
         }
         return max;
     }
  }