剑指offer42.连续子数组的最大和

题目

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

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

测试样例

示例1:

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

思路分析

特征分析：

1. 求最大值
2. 存在一定的规律
   尝试使用动态规划解决

状态定义：
n表示下标为n的那个数
dp[n] 为，以第n数结尾的，子数组集合中，和为最大，的那个子数组的和

转移方程：

1. dp[n] 为n前一个dp[n-1] + num[n]
2. 或者dp[n-1]为负数那么，直接dp[n] = num[n]
   所以
   dp[n] = max(num[n],dp[n-1] + num[n])

初始值
dp[0] = num[0]

代码

自顶向下使用

package 剑指offer.动态规划.offer42;

import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

//自顶向下结合记忆搜索，采用递归的方式书写
public class Solution {


    public static void main(String[] args) {

        Solution solution = new Solution();

        int[] test  ={-2,1,-3,4,-1,2,1,-5,4};

        int res = solution.maxSubArray(test);

        System.out.println(res);


    }


    /**
     * 思路分析
     * 1. 暴力循环
     *
     * 2. 优化暴力循环以及求解最大值问题考虑使用动态规划
     *
     * 含义：dp[n]表示前n个中以n结尾的子序列的最大值，要么就加上前面的最大子集，要么就是本身
     * 转移方程： dp[n] = max(dp[n-1] + nums[n],nums[n])
     * dp[0] = num[0];
     * @param nums
     * @return
     */

    Map<Integer, Integer> remember = new HashMap<>();
    public int maxSubArray(int[] nums) {
        int res = 0;

        int n = nums.length-1;
        dp(n, nums);

        //求存放的最大值
        int length = remember.size();
        Collection<Integer> values = remember.values();
        Object[] objects = values.toArray();
        Arrays.sort(objects);

        res = (Integer)objects[length-1];


        return res;
    }

    public int dp(int n,int[] nums){
        int tempRes = 0;

        if(n == 0){
            tempRes = nums[0];
        }

        if(n >= 1){
            if(remember.containsKey(n)){
                tempRes = remember.get(n);
            }else {
                int beforeRes = dp(n-1,nums);
                //这里一定要与自己进行比较，可以使用dp[1] = dp[0] + nums[1]如果dp[0]是负的，不如直接nums[1]
                tempRes = Math.max(beforeRes + nums[n],nums[n]) ;
            }
        }



        remember.put(n,tempRes);
        return tempRes;
    }

}

自底向上使用循环的方式

package 剑指offer.动态规划.offer42;

//自底向上顺着推
public class Solution1 {


    public static void main(String[] args) {

        Solution solution = new Solution();

        int[] test  ={-2,1,-3,4,-1,2,1,-5,4};

        int res = solution.maxSubArray(test);

        System.out.println(res);


    }



    public int maxSubArray(int[] nums) {

        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int length = nums.length;
        int res = dp[0];

        for (int i = 1; i < length; i++) {
            dp[i] = Math.max(nums[i],nums[i] + dp[i-1]);
            res = Math.max(res,dp[i]);
        }

        return res;
    }


}