解法一 动态规划思路一

用一个二维数组 dp[ i ][ len ] 表示从下标i开始，长度为 len 的子数组的元素和。

这样长度是 len+1 的子数组就可以通过长度是 len 的子数组去求，也就是下边的递推式，
dp [ i ] [ len + 1 ] = dp[ i ] [ len ] + nums [ i + len - 1]。

考虑到求 i+1的情况的时候，我们只需要 i 时候的情况，所有我们其实没必要用一个二维数组，直接用一维数组就可以了。

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        int max = Integer.MIN_VALUE;
        for(int len = 1; len <= n; len++){
            for(int i = 0; i <= n - len; i++){
                //直接覆盖掉前面对应的情况
                dp[i] = dp[i] + nums[i + len - 1];
                //更新max
                if(dp[i] > max){
                    max = dp[i];
                }
            }
        }
        return max;
    }
}

时间复杂度：O(n^2)
空间复杂度：O(n)

解法二 动态规划思路二

用一个一维数组 dp[i] 表示以下标 i 结尾的子数组的元素的最大的和，也就是这个子数组最后一个元素是下边为 i 的元素，并且这个子数组是所有以 i 结尾的子数组中，和最大的。

这样的话就有两种情况，

• 如果 dp[ i-1 ] < 0，那么 dp[ i ] = nums [ i ]。
• 如果 dp[ i-1 ] >= 0，那么 dp[ i ] = dp [ i-1 ] + nums[ i ]。

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        int max = nums[0];
        dp[0] = nums[0];
        for(int i = 1; i < n; i++){
            //两种情况更新 dp[i]
            if(dp[i - 1] < 0){
                dp[i] = nums[i];
            }else{
                dp[i] = dp[i - 1] + nums[i];
            }
            max = Math.max(max,dp[i]);
        }
        return max;
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

解法三 折半

假设我们有了一个函数int getSubMax(int start, int end, intnums)，可以得到 num [ start, end ）中子数组最大值。

如果，start == end，那么 getSubMax 直接返回 nums[ start ] 就可以了。

if (start == end){
	return nums[start];
}

然后对问题进行分解。

先找一个 mid , mid = ( start + end ) / 2

然后，对于我们要找的和最大的子数组有两种情况：

• mid 不在我们要找的子数组中
  这样的话，子数组的最大值要么是 mid 左半部分数组的子数组产生，要么是右边的产生，最大值的可以利用 getSubMax 求出来。
  int leftMax = getSubMax(start，mid，nums);
  int rightMax = getSubMax(mid + 1，end，nums);
• mid 在我们要找的子数组中
  这样的话，我们可以分别从 mid 左边扩展，和右边扩展，找出两边和最大的时候，然后加起来就可以了。当然如果，左边或者右边最大的都小于 0，我们就不加了。

代码：

class Solution {
    private int getSubMax(int start, int end, int[] nums){
        //递归出口
        if(start == end){
            return nums[start];
        }
        int mid = (start + end) / 2;
        //要找的数组不包含 mid，然后得到左边和右边最大的值
        int leftMax = getSubMax(start, mid, nums);
        int rightMax = getSubMax(mid + 1, end, nums);
        //要找的数组包含 mid
        int containsMidMax = getContainMidMax(start, end, mid, nums);
        //返回它们 3 个中最大的
        return Math.max(containsMidMax, Math.max(leftMax, rightMax));
    }

    private int getContainMidMax(int start, int end, int mid, int[] nums){
        int containMidLeftMax = 0; //初始化为 0，防止最大的值也小于 0
        //找左边最大
        if(mid > 0){
            int sum = 0;
            for(int i = mid - 1; i >= 0; i--){
                sum += nums[i];
                if(sum > containMidLeftMax){
                    containMidLeftMax = sum;
                }
            }
        }
        int containMidRightMax = 0;
        //找右边最大
        if(mid < end){
            int sum = 0;
            for(int i = mid + 1; i <= end; i++){
                sum += nums[i];
                if(sum > containMidRightMax){
                    containMidRightMax = sum;
                }
            }
        }
        return containMidLeftMax + nums[mid] + containMidRightMax;
    }

    public int maxSubArray(int[] nums) {
        return getSubMax(0, nums.length - 1, nums);
    }
}

时间复杂度：O(n log (n))

由于 getContainMidMax 这个函数耗费了 O(n)。所以时间复杂度反而相比之前的算法变大了。

解法一和解法二的动态规划，只是在定义的时候一个表示以 i 开头的子数组，一个表示以 i 结尾的子数组，却造成了时间复杂度的差异。问题就是解法一中求出了太多的没必要的和，不如解法二直接，只保存最大的和。解法三，一半一半的求，从而使问题分解，也是经常遇到的思想。