最大子序列和（分治法、动态规划法实现）

package algorithm;
// 最大子序列和
/*
* 给定一个整数序列，返回该序列中和最大的连续子序列；
* 思路：
* 方法一：动态规划：
* 从第一个元素开始，往后求和，并保存当前求到的最大和，
*   当目前和大于0的时候说明之前的子序列对后边的序列有增益效果，则继续往后求和；
*   当目前和小于1的时候说明之前的子序列对后边的序列没有增益效果，则从当前元素开始继续求和——将当前和更新为当前值
*   每次求和之后更新最大值
* 方法二：分治法：
* 每次将序列分为左右大致相等的两个子序列，则最大子序列有三种情况：
*   1、最大子序列存在右子序列中
*   2、最大子序列存在于左子序列中；
*   3、最大子序列存在于跨越中间元素的连续序列中
* 对左右子序列进行递归求和即可，关键是中间序列的求和：
*   分别从中间开始，向左右两边求和，直至左右边界，然后返回max(lSum,rSum,lSum+rSum);
* 最后返回max（rSubArray,lSubArray,rSubarray+lSubArray）即可；
*/

//测试
public class maxSubArray {
    public static void main(String[]args){
        int nums[]={-2,1,-3,4,1,2,1,-5,4};
        System.out.println(dp.maxSubArrayDp(nums));
        System.out.println(dc.maxSubArray(nums,0,nums.length-1));
    }
}
//dp
class dp{
   public static int maxSubArrayDp(int []nums){
        int res=nums[0];
        int sum=0;
        for(int num:nums){
            if(sum>0)sum+=num;
            else sum=num;
            res=Math.max(res,sum);
        }
        return res;
    }
}

//分治
class dc{
    //中间子序列求和
    static int maxSubArrayCrossMid(int []nums,int l,int r){

        if(l==r)return nums[r];
        int index=(r+l)/2;
        int lres=nums[index];
        int rres=lres;
        int lSum=0;
        int rSum=lSum;
        //左半边
        while(index>=l){
            lSum+=nums[index];
            index--;
            lres=Math.max(lres,lSum);
        }index=(r+l)/2;
        //右半边
        while(index<=r){
            rSum+=nums[index];
            index++;
            rres=Math.max(rres,rSum);
        }
        //这里注意rres+lres会将中间元素多加一次，需要减去
        return Math.max(rres+lres-nums[(r+l)/2],Math.max(rres,lres));
    }
    public static int maxSubArray(int[] nums,int l,int r) {
        if (l == r) return nums[r];
        return Math.max(maxSubArrayCrossMid(nums, l, r),Math.max(maxSubArray(nums, l, (l + r) / 2),maxSubArray(nums, (r+l)/2+1,r)));
        //int midSum = maxSubArrayCrossMid(nums, l, r);
        //int lsum = maxSubArray(nums, l, (l + r) / 2);
        //int rsum = maxSubArray(nums, (r + l) / 2 + 1, r);
        //return(Math.max(Math.max(lsum,rsum),midSum));
    }
}

运行结果：