leetcode 53. Maximum Subarray

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Example:

Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

tag:贪心，leetcode,divide and conquer, array, dp

method 1

使用贪心，声明一个变量curMax代表当前连续子序列的最大和，每往后加一个数就判断是否＜０，如果小于０，那就没必要继续往下加，令curMax = 0

public int maxSubArray(int[] nums) {
        if (nums.length == 1)
            return nums[0];

        int max = Integer.MIN_VALUE;
        int cur = 0;
        for (int i = 0; i < nums.length; i++) {
            cur += nums[i];
            max = Math.max(max, cur);

            if (cur <= 0)
                cur = 0;

        }
        return max;
    }

method 2

使用动态规划，dp[i]表示以nums[i]结尾的最大子数组和，所以dp[i] = (dp[i-1] + nums[i],nums[i])
*而不是表示为dp[i,j]表示从i到j的最大子数组，有两个参数的时候更灵活，计算更复杂，而dp[i]只需考虑是dp[i-1]大还是dp[i-1]+nums[i]大

但要注意，在最大连续乘积和问题中，需要对转移方程作出一点改进，因为可能出现两个负数夹杂１个正数的情况

public int maxSubArray2(int[] nums) {
        if (nums.length == 1)
            return nums[0];

        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int max = dp[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
            max = Math.max(dp[i], max);
        }

        return max;
    }

method 3

分治法

将一个数组分为两份，那么最大子数组只能从三个地方得到

• 1、在左边的最大子数组
• 2、在右边的最大子数组
• 3、穿过中间节点的最大子数组

这个问题使用分治法倒是很意外，没想到这样的问题也可以用分治法．如果能将大问题化为小问题，那么都应该尝试一下分治法

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

    private int maxSubArraySum(int[] nums, int l, int h){
        if (l == h)
            return nums[l];

        int m = (l+h)/2;

        return Math.max(Math.max(maxSubArraySum(nums,l,m),maxSubArraySum(nums,m+1,h)),
                crossMidSum(nums,l,m,h));
    }

    private int crossMidSum(int[] nums,int l, int m, int h){
        int sum = 0;
        int leftSum = Integer.MIN_VALUE;
        for (int i = m; i >= l; i--) {
            sum += nums[i];
            leftSum = Math.max(leftSum,sum);
        }

        sum = 0;
        int rightSum = Integer.MIN_VALUE;
        for (int i = m+1; i <= h; i++) {
            sum += nums[i];
            rightSum = Math.max(rightSum,sum);
        }

        return leftSum+rightSum;
    }

summary;

1. 动态规划dp[i]含义收集：dp[i]表示以nums[i]结尾的最大子数组和
2. 在开始想问题之前，思考是不是能用分治法