Maximum Subarray / Best Time To Buy And Sell Stock 与 prefixNum

这两个系列的题目其实是同一套题，可以互相转换。

首先我们定义一个数组: prefixSum （前序和数组）

Given nums:　　[1, 2, -2, 3]

prefixSum:　 [0, 1, 3, 1, 4 ]

现在我们发现对prefixSum做Best Time To Buy And Sell Stock和对nums做Maximum Subarray，结果相同。

接下来我们就利用prefixSum解这两个系列的题目。

Maximum Subarray

Question

Given an array of integers, find a contiguous subarray which has the largest sum.

Example

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

Note

The subarray should contain at least one number.

Solution

Sum of subarray i to j can be calculated by prefixSum[j] - prefixSum[i - 1].

Two variables, so we hope to make prefixSum[i - 1] minimum, while prefixSum[j] maximum.

Example

nums　　　　   　　1　　1　　1　　-4　　6　　1　　-5

prefixSum　　0　　1　　2　　3　　-1　　5　　6　　1

min　　　　　 0　　0　　0　　0　　0　　-1　　-1　 -1

max sub　　   0　　1　　2　　3　　3　　 6　　7　　7

public class Solution {
    public int maxSubArray(ArrayList<Integer> nums) {
        int length = nums.size();
        // Construct prefixSum
        int[] prefixSum = new int[length + 1];
        prefixSum[0] = 0;
        for (int i = 0; i < length; i++)
            prefixSum[i + 1] = prefixSum[i] + nums.get(i);
        // Traverse prefixSum
        // min: minimum number before i
        // result: maximum subarray from 0 to i
        int min = 0;
        int result = Integer.MIN_VALUE;
        for (int i = 0; i < length; i++) {
            int current = prefixSum[i + 1];
            result = Math.max(result, current - min);
            min = Math.min(current, min);
        }
        return result;
    }
}

Similar: Minimum Subarray

public class Solution {    
    public int minSubArray(ArrayList<Integer> nums) {
        int length = nums.size();
        int sum = 0;
        int maxSum = 0;
        int minSum = Integer.MAX_VALUE;
        for (int i = 0; i < length; i++) {
            sum += nums.get(i);
            minSum = Math.min((sum - maxSum), minSum);
            maxSum = Math.max(maxSum, sum);
        }
        return minSum;
    }
}

Maximum Subarray II

Question

Given an array of integers, find two non-overlapping subarrays which have the largest sum.

The number in each subarray should be contiguous.

Return the largest sum.

Example

For given [1, 3, -1, 2, -1, 2], the two subarrays are [1, 3] and [2, -1, 2] or [1, 3, -1, 2] and [2], they both have the largest sum 7.

Note

The subarray should contain at least one number

Solution

The problem can be translated as

Finding a strip line in the array, to make the sum of its max left subarray and max right subarray is max.

We can traverse the input array and list all possible value of the strip line, and then calculated its left max and right max. The time complexity is O(n²). But this still wastes a lot of time for duplicated calculation.

Actually we can just travers twice and get result. Time complexity is O(n).

maxLeft is max subarray on strip line's left side (inclusive). maxRight is max subarray on strip line's right side (inclusive).

nums　　　　   　　     1　　1　　1　　-4　　6　　1　　-5

prefixSumLeft　　0　　1　　2　　3　　-1　　5　　6　　1

minL　　　　　　  0　　0　　0　　0　　 0　　-1　 -1　  -1

maxLeft　　　  　　　 1　　2　　3　　 3　　 6　　7　　7

prefixSumRight   　　 1　　 0　　-1  　-2　　2　  -4　　-5　　0

minR　　　　　　　　  -5　 -5　　-5　　-5　  -5　 -5　　0　　 0

maxRight　　　　　　7　　7　　 7　　 7　　 7　　 1　　0

public class Solution {
    
    public int maxTwoSubArrays(ArrayList<Integer> nums) {
        int length = nums.size();
        int[] left = new int[length];
        int[] right = new int[length];
        int sum = 0;
        int minSum = 0;
        int maxSum = Integer.MIN_VALUE;
        // left
        for (int i = 0; i < length; i++) {
            sum += nums.get(i);
            maxSum = Math.max(maxSum, (sum - minSum));
            left[i] = maxSum;
            minSum = Math.min(minSum, sum);
        }
        // right
        sum = 0;
        minSum = 0;
        maxSum = Integer.MIN_VALUE;
        for (int i = length - 1; i >= 0; i--) {
            sum += nums.get(i);
            maxSum = Math.max(maxSum, (sum - minSum));
            right[i] = maxSum; 
            minSum = Math.min(minSum, sum);
        }
        
        int result = Integer.MIN_VALUE;
        for (int i = 0; i < length - 1; i++)
            result = Math.max(result, left[i] + right[i + 1]);
        return result;        
    }
}

Maximum Subarray III

Question

Given an array of integers and a number k, find k non-overlapping subarrays which have the largest sum.

The number in each subarray should be contiguous.

Return the largest sum.

Example

Given [-1,4,-2,3,-2,3], k=2, return 8

Note

The subarray should contain at least one number

Solution