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

剑指 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;
       }
    }
    
©️2020 CSDN 皮肤主题: 1024 设计师:上身试试 返回首页