Maximum Sum of 3 Non-Overlapping Subarrays

In a given array nums of positive integers, find three non-overlapping subarrays with maximum sum.

Each subarray will be of size k, and we want to maximize the sum of all 3*k entries.

Return the result as a list of indices representing the starting position of each interval (0-indexed). If there are multiple answers, return the lexicographically smallest one.

Example:

Input: [1,2,1,2,6,7,5,1], 2
Output: [0, 3, 5]
Explanation: Subarrays [1, 2], [2, 6], [7, 5] correspond to the starting indices [0, 3, 5].
We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically larger.

Note:

• nums.length will be between 1 and 20000.
• nums[i] will be between 1 and 65535.
• k will be between 1 and floor(nums.length / 3).

思路：这个题目还是比较巧妙的，要求三段的和最大，核心算法就是：固定中间的一段subarry，分别用O(1)的时间去求左边部分的最大的subarry和，右边部分的最大的subarry的和。怎么用O(1)的时间去求subarry，很简单，prefixsum。但是怎么O(1)的去求一个大区间里面，哪一段的subarry是最大的，这个点就要用dp来pre compute，用leftdp记录到目前为止，从左往右看，到第i为止的最大的k size的subarry的起点index，同理：rightdp记录从右往左看 k size最大和的起点；这样有了这两个array，我就可以一口气算出

[0, i] [i, i + k -1] [i + k, n - 1] 三个区间段里面，哪三段的和最大，左边和右边可以O(1)算出来，中间的i在动，但是也可以O(1)计算出来；

prefixsum index的推倒，要熟练；

sum[i, j] = prefixsum[j] - prefixsum[i - 1] 由于 array +1了，所以 prefixsum[j + 1] - prefixsum[i] 

i 跟j之间有k，那么  j = i + k - 1 <==>  i = j - k + 1;

从左往右计算，是j在移动，所以消除 i，prefixsum[j + 1] - prefixsum[j - k + 1];

从右往左计算，是i在移动，所以消除 j，prefixsum[i + k - 1 + 1] - prefixsum[i] = prefixsum[i + k] - prefixsum[i];

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        int n = nums.length;
        int[] presum = new int[n + 1];
        for(int i = 0; i < n; i++) {
            presum[i + 1] = presum[i] + nums[i];
        }
        
        // 记录到目前i为止的，从左往右看，最大的subarry的和的起始位子；
        int[] leftdp = new int[n];
        // 记录到目前i为止的，从右往左看，最大的subarry的和的起始位子；
        int[] rightdp = new int[n];
        
        leftdp[k] = 0;
        for(int j = k, total = presum[k] - presum[0]; j < n; j++) {
            if(presum[j + 1] - presum[j - k + 1] > total) {
                total = presum[j + 1] - presum[j - k + 1];
                leftdp[j] = j - k + 1;
            } else {
                leftdp[j] = leftdp[j - 1];
            }
        }
        
        rightdp[n - k] = n - k;
        for(int i = n - k - 1, total = presum[n] - presum[n - k]; i >= 0; i--) {
            if(presum[i + k] - presum[i] >= total) {
                total = presum[i + k] - presum[i];
                rightdp[i] = i;
            } else {
                rightdp[i] = rightdp[i + 1];
            }
        }
        
        // left,     middle,        right;
        // [0, i], [i, i + k - 1], [i + k, n - 1];
        int[] res = {-1,-1,-1};
        int maxsum = 0;
        // 左边最起码要有k个，所以start = k，右边也是要有k个，那么起点就是倒数第二个k个，也就是 n - 2*k;
        // 核心算法:就是固定中间的subarry，然后一口气算出各个subarry的和，怎么算，
        // 也就是pre calculate的leftdp, rightdp, 
        // 然后用leftdp 和rightdp O(1)去算各个subarry的和；
        for(int i = k; i <= n - 2 * k; i++) {
            int l = leftdp[i - 1];
            int r = rightdp[i + k];
            int cursum = (presum[l + k] - presum[l]) 
                        + (presum[i + k] - presum[i]) 
                        + (presum[r + k] - presum[r]);
            if(cursum > maxsum) {
                maxsum = cursum;
                res[0] = l;
                res[1] = i;
                res[2] = r;
            }
        }
        return res;
    }
}