题目描述（简单难度）
给一个数组，找出一个连续的子数组，长度任意，和最大。
解法一 动态规划思路一
用一个二维数组 dp[ i ] [ len ] 表示从下标 i 开始，长度为 len 的子数组的元素和。
这样长度是 len + 1 的子数组就可以通过长度是 len 的子数组去求，也就是下边的递推式，
dp [ i ] [ len + 1 ] = dp[ i ] [ len ] + nums [ i + len - 1 ]。
当然，和第 5 题一样，考虑到求 i + 1 的情况的时候，我们只需要 i 时候的情况，所有我们其实没必要用一个二维数组，直接用一维数组就可以了。
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²）。
空间复杂度：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 ]。
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
max = Math.max(max, dp[i]);
}
return max;
}
时间复杂度： O（n）。
空间复杂度：O（n）。
当然，和以前一样，我们注意到更新 i 的情况的时候只用到 i - 1 的时候，所以我们不需要数组，只需要两个变量。
public int maxSubArray(int[] nums) {
int n = nums.length;
//两个变量即可
int[] dp = new int[2];
int max = nums[0];
dp[0] = nums[0];
for (int i = 1; i < n; i++) {
//利用求余，轮换两个变量
if (dp[(i - 1) % 2] < 0) {
dp[i % 2] = nums[i];
} else {
dp[i % 2] = dp[(i - 1) % 2] + nums[i];
}
max = Math.max(max, dp[i % 2]);
}
return max;
}
时间复杂度： O（n）。
空间复杂度：O（1）。
再粗暴点，直接用一个变量就可以了。
public int maxSubArray(int[] nums) {
int n = nums.length;
int dp = nums[0];
int max = nums[0];
for (int i = 1; i < n; i++) {
if (dp < 0) {
dp = nums[i];
} else {
dp= dp + nums[i];
}
max = Math.max(max, dp);
}
return max;
}
而对于
if (dp < 0) {
dp = nums[i];
} else {
dp= dp + nums[i];
}
其实也可以这样理解，
dp= Math.max(dp + nums[i],nums[i]);
然后就变成了这里提到的算法。
解法三 折半
题目最后说
If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.
[这里](If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.)找到了种解法，分享下。
假设我们有了一个函数 int getSubMax(int start, int end, int[] nums) ，可以得到 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 ，我们就不加了。
int containsMidMax = getContainMidMax(start, end, mid, nums); private int getContainMidMax(int start, int end, int mid, int[] nums) { int containsMidLeftMax = 0; //初始化为 0 ，防止最大的值也小于 0 //找左边最大 if (mid > 0) { int sum = 0; for (int i = mid - 1; i >= 0; i--) { sum += nums[i]; if (sum > containsMidLeftMax) { containsMidLeftMax = sum; } } } int containsMidRightMax = 0; //找右边最大 if (mid < end) { int sum = 0; for (int i = mid + 1; i <= end; i++) { sum += nums[i]; if (sum > containsMidRightMax) { containsMidRightMax = sum; } } } return containsMidLeftMax + nums[mid] + containsMidRightMax; }最后，我们只需要返回这三个中最大的值就可以了。
综上，递归出口，问题分解就都有了。
public int maxSubArray(int[] nums) {
return getSubMax(0, nums.length - 1, nums);
}
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 containsMidLeftMax = 0; //初始化为 0 ，防止最大的值也小于 0
//找左边最大
if (mid > 0) {
int sum = 0;
for (int i = mid - 1; i >= 0; i--) {
sum += nums[i];
if (sum > containsMidLeftMax) {
containsMidLeftMax = sum;
}
}
}
int containsMidRightMax = 0;
//找右边最大
if (mid < end) {
int sum = 0;
for (int i = mid + 1; i <= end; i++) {
sum += nums[i];
if (sum > containsMidRightMax) {
containsMidRightMax = sum;
}
}
}
return containsMidLeftMax + nums[mid] + containsMidRightMax;
}
时间复杂度：O（n log ( n )）。由于 getContainMidMax 这个函数耗费了 O（n）。所以时间复杂度反而相比之前的算法变大了。
空间复杂度：
总
解法一和解法二的动态规划，只是在定义的时候一个表示以 i 开头的子数组，一个表示以 i 结尾的子数组，却造成了时间复杂度的差异。问题就是解法一中求出了太多的没必要的和，不如解法二直接，只保存最大的和。解法三，一半一半的求，从而使问题分解，也是经常遇到的思想。
更多详细通俗题解详见 leetcode.wang 。
