分治法——最大子序和（Leetcode 53）

原题如下:

---

1、先简单记录一下动态规划算法：

找到公式：

dp[i]=max(dp[i-1]+nums[i],nums[i])

其中dp[i]表示以nums[i]结尾的最大连续和。

这个公式就理解成：

对于当前这个数字，要么前面的对你有益，你加上；
要么前面对你无益，你不需要前面的。

所以，最后再额外使用一个空间，用来保留目前为止认为的最大值即可。

---

2、分治法

分治法，问题划分成子问题，再合并。

连续子串的划分如下:

1、左半边子串
2、右半边子串
3、横跨中间值的任意子串

确实就是这三类了，求出这三类的结果，然后取最大值即可。

思考的时候可以这样想，每个子串又可以分治，递归之后可以认为只有数组只有三个值:[a,b,c]。当然，这其实不是最终结果，只是便于思考。

所以函数可以这样写:

if(length==1){
	return nums[0];
}else{
	return max(left,mid,right)
}

left和right比较简单，递归到最后，肯定是length为1。 问题在于，mid怎么求。

mid的求解思路有点暴力:

1、从mid开始，往左遍历相加，使用maxLeft记录最大值。
2、从mid+1开始，往右遍历相加，使用rightLeft记录最大值,小于0就丢弃。

所以函数就变成了下面这个样子:

function maxSubArray(int[] nums,int start,int end){
	if(start==end){
	return nums[0];
	}
	int center=(start+end)/2;
	int left=maxSubArray(nums,start,center);
	int right=maxSubArray(nums,center+1,end);
	int mid=getMid();//这里为了思路清晰没有详述，求解思路就是上面所说，具体代码在下面
	return max(left,mid,right);
}

最后补充一下，让我困惑了一会儿的点，那就是这个函数有两个return，在干嘛？

概略地，

第一个return是递归的return，或者理解为左右子串的return
第二个return是分治的return，理解为子串的return，包括中间子串

实在想不清楚，就像我之前说的，用[2,-1,3]这个数组理一下。

---

下面是具体代码

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

    private int maxSubArrayDivideWithBorder(int[] nums, int start, int end) {
        if (start == end) {
            // 只有一个元素，也就是递归的结束情况
            return nums[start];
        }

        // 计算中间值
        int center = (start + end) / 2;
        int leftMax = maxSubArrayDivideWithBorder(nums, start, center); // 计算左侧子序列最大值
        int rightMax = maxSubArrayDivideWithBorder(nums, center + 1, end); // 计算右侧子序列最大值

        // 下面计算横跨两个子序列的最大值

        // 计算包含左侧子序列最后一个元素的子序列最大值
        int leftCrossMax = Integer.MIN_VALUE; // 初始化一个值
        int leftCrossSum = 0;
        for (int i = center ; i >= start ; i --) {
            leftCrossSum += nums[i];
            leftCrossMax = Math.max(leftCrossSum, leftCrossMax);
        }

        // 计算包含右侧子序列最后一个元素的子序列最大值
        int rightCrossMax = nums[center+1];
        int rightCrossSum = 0;
        for (int i = center + 1; i <= end ; i ++) {
            rightCrossSum += nums[i];
            rightCrossMax = Math.max(rightCrossSum, rightCrossMax);
        }

        // 计算跨中心的子序列的最大值
        int crossMax = leftCrossMax + rightCrossMax;

        // 比较三者，返回最大值
        return Math.max(crossMax, Math.max(leftMax, rightMax));
    }

欢迎指导。