Leetcode最大子序和（暴力解法，动态规划，分治法）

示例:

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

进阶:

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

一，暴力解法：

class Solution {
    public int maxSubArray(int[] nums) {
        int max = nums[0];
        for(int i = 0;i < nums.length; i++){
            int sum = 0;
            for(int j = i;j < nums.length; j++){
                sum += nums[j];
                if(max < sum){
                    max = sum;
                }
            }
        }
        return max;
    }
}

执行结果：
通过
显示详情
执行用时：134 ms, 在所有 Java 提交中击败了5.09% 的用户
内存消耗：40 MB, 在所有 Java 提交中击败了18.89% 的用户

二，动态规划：

class Solution {
    public int maxSubArray(int[] nums) {
        if (nums == null) {
            return 0;
        }
        int max = nums[0];    // 全局最大值
        int sMax = nums[0];  // 前一个子组合的最大值
        for (int i = 1; i < nums.length; i++) {
            if (sMax > 0) {
                // 前一个子组合最大值大于0，正增益
                sMax = sMax + nums[i];
            } else {
                // 前一个子组合最大值小于0，抛弃前面的结果
                sMax = nums[i];
            }
            // 计算全局最大值
            max = Math.max(max,sMax);
        }
        return max;

    }
}

执行结果：
通过
显示详情
执行用时：1 ms, 在所有 Java 提交中击败了95.97% 的用户
内存消耗：40.1 MB, 在所有 Java 提交中击败了5.03% 的用户

自我小结：动态规划的主要思路就是将原问题分解成一系列的与原问题相似的子问题，减少计算的复杂度。

动态算法的讲解地址
leetcode题解地址

三，分治法

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 = nums[center]; // 初始化一个值
        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));
    }

执行结果：
通过
显示详情
执行用时：1 ms, 在所有 Java 提交中击败了95.97% 的用户
内存消耗：39.6 MB, 在所有 Java 提交中击败了83.24% 的用户
（这是大佬的代码）

分治算法和动态规划有什么不同和联系？

1. 分治法与动态规划主要共同点:
   二者都要求原问题具有最优子结构性质,都是将原问题分而治之,分解成若干个规模较小(小到很容易解决的程序)的子问题.然后将子问题的解合并,形成原问题的解.

2. 分治法与动态规划实现方法:
   ① 分治法通常利用递归求解.
   ② 动态规划通常利用迭代法自底向上求解,但也能用具有记忆功能的递归法自顶向下求解.

3. 分治法与动态规划主要区别:
   ① 分治法将分解后的子问题看成相互独立的.
   ② 动态规划将分解后的子问题理解为相互间有联系,有重叠部分.
   百度出处