53.最大子序和-Java实现

相关标签

• 数组
• 分治算法
• 动态规划

题目描述

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:

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

进阶:

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

 

解法1：贪心算法/动态规划（√）

 
动态转移方程：

f[i] = max{ nums[i] , f[i-1] + nums[i] }
 

初始条件：

f[0] = nums[0]

 
代码：

class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0;
        int sum = nums[0];
        for (int i = 0; i < nums.length; i++) {
            // 如果前i项的和小于第i项的值 则将pre置为当前项的值
            pre = Math.max(pre + nums[i] , nums[i]);
            sum = Math.max(sum , pre);
        }
        return sum;
    }
}

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

执行用时：1ms
 

解法2：分治算法（√）

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

    /**
     * 计算[left,right]的最大子序和
     * @param nums
     * @param left
     * @param right
     * @return
     */
    public static int maxSubArraySum(int[] nums, int left, int right) {
    
        if (left == right) {
            return nums[left];
        }
        int mid = (left + right) / 2;
        // 如果最大子序和落在mid左边，计算[left,mid]的最大子序和
        int maxLeftSum = maxSubArraySum(nums, left, mid);
        
        // 如果最大子序和落在mid右边，计算[mid+1,right]的最大子序和
        int maxRightSum = maxSubArraySum(nums, mid + 1, right);
        
        // 如果最大子序和跨中点mid
        int maxMidSum = findMaxCrossingSubArray(nums, left, mid, right);
        
        // 返回左、中、右三个值中最大值即为最大子序和
        return Math.max(Math.max(maxLeftSum,maxRightSum),maxMidSum);
    }

    /**
     * 计算跨中点mid的最大子序和，分别计算从mid到左和从mid+1到右的最大子序和相加
     * @param nums
     * @param left
     * @param mid
     * @param right
     * @return
     */
    public static int findMaxCrossingSubArray(int[] nums, int left, int mid, int right) {
    
        //类似寻找最大最小值的题目，初始值一定要定义成理论上的最小最大值(可能为负数组）
        // maxLeftBorderSum ：从 mid 往左找到的最大子序和
        // maxRightBorderSum ：从 mid+1 往右找到的最大子序和
        int maxLeftBorderSum = Integer.MIN_VALUE, maxRightBorderSum = Integer.MIN_VALUE, sum = 0;
        
        for (int i = mid; i >= left; --i) {
            sum +=nums[i];
            maxLeftBorderSum = Math.max(maxLeftBorderSum,sum);
        }
        
        // 计算从mid+1 到right的最大子序和，sum清零
        sum = 0;
        for (int i = mid + 1; i <= right; ++i) {
            sum+=nums[i];
            maxRightBorderSum = Math.max(maxRightBorderSum,sum);
        }
        return maxLeftBorderSum + maxRightBorderSum;
    }
}

时间复杂度：O(n)，空间复杂度：O(logn）

执行用时：3ms

「解法2」相较于「解法1」来说，时间复杂度相同，但是因为使用了递归，运行的时间略长，空间复杂度也不如解法1优秀，而且难以理解。那么这种方法存在的意义是什么呢？
对于这道题而言，确实是如此的。但是仔细观察「解法2」，它不仅可以解决区间 [0, n - 1]，还可以用于解决任意的子区间 [l, r] 的问题。如果我们把 [0, n - 1]分治下去出现的所有子区间的信息都用堆式存储的方式记忆化下来，即建成一颗真正的树之后，我们就可以在 O(logn) 的时间内求到任意区间内的答案，我们甚至可以修改序列中的值，做一些简单的维护，之后仍然可以在 O(logn) 的时间内求到任意区间内的答案，对于大规模查询的情况下，这种方法的优势便体现了出来。这棵树就是——线段树。