最大子序和，给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

题记：
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例 1：

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

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

• 1 <= nums.length <= 10 ^ 5
• -10 ^ 4 <= nums[i] <= 10 ^ 4

进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

题目来源：
作者：LeetCode
链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/xn3cg3/
来源：力扣（LeetCode）

解题方法：

一：动态规划解决

这题是让求最大的连续子序和，如果不是连续的非常简单，只需要把所有的正数相加即可。但这里说的是连续的，中间可能掺杂负数，如果求出一个最大子序和在加上负数肯定要比原来小了。解这题最简单的一种方式就是使用动态规划。

我们先来了解一下动态规划的几个步骤

1，确定状态
2，找到转移公式
3，确定初始条件以及边界条件
4，计算结果。

最后一个不用看，只看前3个就行，因为前3个一旦确定，最后一个结果也就出来了。我们试着找一下

1，定义dp[i] 表示数组中下标 i为右端点的连续子数组的最大和。

2，如果要计算下标i为右端点的连续子数组的最大和，也就是计算dp[i]，只需要判断 dp[i-1] 是大于0还是小于0。如果 dp[i-1] 大于0，就继续累加，dp[i]=dp[i-1]+num[i]。如果 dp[i-1] 小于0，我们直接把前面的舍弃，也就是说重新开始计算，否则会越加越小的，直接让dp[i]=num[i]。所以转移公式如下

dp[i]=num[i]+max(dp[i-1],0);

3，边界条件判断，当i等于0的时候，也就是前1个元素，他能构成的最大和也就是他自己，所以

dp[0]=num[0];

找到了上面的转移公式，代码就简单多了，来看下

public int maxSubArray(int[] num) {
    int length = num.length;
    int[] dp = new int[length];
    //边界条件
    dp[0] = num[0];
    int max = dp[0];
    for (int i = 1; i < length; i++) {
        //转移公式
        dp[i] = Math.max(dp[i - 1], 0) + num[i];
        //记录最大值
        max = Math.max(max, dp[i]);
    }
    return max;
}

转换为PHP代码为：

function maxSubArray($nums) {
    //动态规划
    $length = count($nums);
    $dp = [];
    //边界条件
    $dp[0] = $nums[0];
    $max = $dp[0];
 	for($i = 1	; $i < $length; $i++){
        //转移公式
        $dp[$i] = max($dp[$i - 1], 0) + $nums[$i];
        //记录最大值
        $max = max($max,$dp[$i]);
    }
    return $max;
}

二：代码优化

仔细看下上面的代码会发现，我们申请了一个长度为length的数组，但在转移公式计算的时候，每次计算当前值的时候只会用到前面的那个值，再往前面就用不到了，这样实际上是造成了空间的浪费。这里不需要一个数组，只需要一个临时变量即可，看下代码

public int maxSubArray(int[] num) {
    int length = num.length;
    int cur = num[0];
    int max = cur;
    for (int i = 1; i < length; i++) {
        cur = Math.max(cur, 0) + num[i];
        //记录最大值
        max = Math.max(max, cur);
    }
    return max;
}

转换为PHP代码为：

function maxSubArray($nums) {
    //动态规划优化
    $length = count($nums);
    //边界条件
    $cur = $nums[0];
    $max = $cur;
    for($i = 1; $i < $length; $i++){
        //转移公式
        $cur = max($cur, 0) + $nums[$i];
        //记录最大值
        $max = max($max, $cur);
    }
    return $max;
}

方法来源：
作者：数据结构和算法
链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/xn3cg3/?discussion=OQJnK2
来源：力扣（LeetCode）

附加：分治法

看大佬这里没有写分治法的解决思路，我来补充一个。也可以参考 《算法导论》第四章 – 分治法—和最大的连续子数组部分的内容。

核心思想就是通过分治法，把数组分成三部分的最大和，左边，右边和横跨中点的部分。 而左边和右边是通过递归地求各自横跨中点的最大和来找到的。附一张书上的图

步骤：

1. 算中间最大和croLSum + croRSum
2. 算左半部分最大和lSum
3. 算右半部分最大和rSum
4. 比较以上三个结果的大小，选最大的一个

public int crossMax(int[] nums, int l, int r) {
    if (l >= r) return nums[l];

    int m = l + ((r - l) >> 1); // 计算中点
    int i = m, j = m; // 初始化左右索引
    int croLSum = nums[m]; // 初始化左边最大和为中点的值
    int croRSum = Integer.MIN_VALUE; // 右边负无穷

    int sum = croLSum;
    while(i - 1 >= l) { // 算左边的最大和（包括中点）
        sum += nums[--i];
        croLSum = sum > croLSum ? sum : croLSum;
    }
    
    sum = 0;
    while(j + 1 <= r) { // 算右边的最大和
        sum += nums[++j];
        croRSum = sum > croRSum ? sum : croRSum;
    }

    int lSum = crossMax(nums, l, m); // 递归算左半部分
    int rSum = crossMax(nums, m + 1, r); // 递归算右半部分

    // 比较左边，中间，和右边的最大和，选最大的那个
    return Math.max(croLSum + croRSum, Math.max(lSum, rSum));
}

方法来源：
作者：Oliver
链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/xn3cg3/?discussion=gEALUl
来源：力扣（LeetCode）