Leetcode53 Maximum Subarray

Maximum Subarray

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [−2,1,−3,4,−1,2,1,−5,4],
the contiguous subarray [4,−1,2,1] has the largest sum = 6.

Solution1

• 入门级别的动态规划问题。

public class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length==0) return 0;
        int result = Integer.MIN_VALUE;
        int[] dp = new int[nums.length];
        for(int i=0;i<nums.length;i++){
            dp[i] = Math.max((i>0?dp[i-1]:0)+nums[i],nums[i]);
            result = Math.max(result,dp[i]);
        }
        return result;
    }
}

Solution2

• 因为只跟上一个状态有关，所以可以用滚动数组，而这里本来就是一维的了，所以不需要数组，只用一个变量即可。

public class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length==0) return 0;
        int result = Integer.MIN_VALUE;
        int dp = 0;
        for(int i=0;i<nums.length;i++){
            dp = Math.max(dp+nums[i],nums[i]);
            result = Math.max(result,dp);
        }
        return result;
    }
}

Solution3

• 避免将result设置为最小值，可以这样：

public class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length==0) return 0;
        int result = nums[0];
        int dp = nums[0];
        for(int i=1;i<nums.length;i++){
            dp = Math.max(dp+nums[i],nums[i]);
            result = Math.max(result,dp);
        }
        return result;
    }
}

Solution4

• 提供另一种思路：最大子数组无非是两个前缀和的差值。因此可以遍历数组，求得到遍历位置的前缀和，并且动态维护到遍历位置的最小前缀和，因此最大值只有可能是前缀和减去最小前缀和的差值。

public class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length==0) return 0;
        int result = nums[0], sum = 0, min = 0;
        for(int i=0;i<nums.length;i++){
            sum += nums[i];//前缀和
            result = Math.max(result,sum-min);//当前前缀和减去最小前缀和
            min = Math.min(min,sum);//到目前为止的最小前缀和
        }
        return result;
    }
}