689. 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).
思路：有想到考虑3个特殊数字，有考虑先中间后2边
 * 但是最后还是差一点
 * 
 * 确定中间的interval [i, i+k]，剩下的就一定是2边的啦
 * 一个是[o, i-1], [i+k+1:end]
 * 这2个先预先遍历一遍就可以得到
 * 然后再遍历一遍中间的就ok 

/*
 * 有想到考虑3个特殊数字，有考虑先中间后2边
 * 但是最后还是差一点
 * 
 * 确定中间的interval [i, i+k]，剩下的就一定是2边的啦
 * 一个是[o, i-1], [i+k+1:end]
 * 这2个先预先遍历一遍就可以得到
 * 然后再遍历一遍中间的就ok 
 */
class Solution {
	
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
    	int[] left = new int[nums.length], right = new int[nums.length];
    	
    	int sum = 0;
    	for(int i=0; i<k; i++)	sum += nums[i];
    	left[k-1] = 0;
    	int max = sum;
    	for(int i=k; i<nums.length; i++) {
    		sum += nums[i] - nums[i-k];
    		if(sum > max)	left[i] = i-k+1;
    		else		left[i] = left[i-1];
    		max = Math.max(max, sum);
    	}
    	
    	sum = 0;
    	for(int i=nums.length-1; i>=nums.length-k; i--)	sum += nums[i];
    	right[nums.length-k] = nums.length-k;
    	max = sum;
    	for(int i=nums.length-k-1; i>=0; i--) {
    		sum += nums[i] - nums[i+k];
    		if(sum >= max)	right[i] = i;
    		else		right[i] = right[i+1];
    		max = Math.max(max, sum);
    	}
    	
    	int[] t = new int[nums.length+1];
    	for(int i=1; i<t.length; i++)
    		t[i] = t[i-1] + nums[i-1];
    		
    	max = Integer.MIN_VALUE;
    	int[] ret = new int[3];
    	for(int i=k; i+k<=nums.length-k; i++) {
    		int tmp = t[left[i-1]+k] - t[left[i-1]] + t[right[i+k]+k]-t[right[i+k]] + t[i+k]-t[i];
    		if(tmp > max) {
    			max = tmp;
    			ret[0] = left[i-1];
    			ret[1] = i;
    			ret[2] = right[i+k];
    		}
    	}
    	
    	return ret;
    }

}

自己写的好丑

The question asks for three non-overlapping intervals with maximum sum of all 3 intervals. If the middle interval is [i, i+k-1], where k <= i <= n-2k, the left interval has to be in subrange [0, i-1], and the right interval is from subrange [i+k, n-1].

So the following solution is based on DP.

posLeft[i] is the starting index for the left interval in range [0, i];
posRight[i] is the starting index for the right interval in range [i, n-1]; 

Then we test every possible starting index of middle interval, i.e. k <= i <= n-2k, and we can get the corresponding left and right max sum intervals easily from DP. And the run time is O(n).

class Solution {
public:
    vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {
        int n = nums.size(), maxsum = 0;
        vector<int> sum = {0}, posLeft(n, 0), posRight(n, n-k), ans(3, 0);
        for (int i:nums) sum.push_back(sum.back()+i);
       // DP for starting index of the left max sum interval
        for (int i = k, tot = sum[k]-sum[0]; i < n; i++) {
            if (sum[i+1]-sum[i+1-k] > tot) {
                posLeft[i] = i+1-k;
                tot = sum[i+1]-sum[i+1-k];
            }
            else 
                posLeft[i] = posLeft[i-1];
        }
        // DP for starting index of the right max sum interval
        for (int i = n-k-1, tot = sum[n]-sum[n-k]; i >= 0; i--) {
            if (sum[i+k]-sum[i] > tot) {
                posRight[i] = i;
                tot = sum[i+k]-sum[i];
            }
            else
                posRight[i] = posRight[i+1];
        }
        // test all possible middle interval
        for (int i = k; i <= n-2*k; i++) {
            int l = posLeft[i-1], r = posRight[i+k];
            int tot = (sum[i+k]-sum[i]) + (sum[l+k]-sum[l]) + (sum[r+k]-sum[r]);
            if (tot > maxsum) {
                maxsum = tot;
                ans = {l, i, r};
            }
        }
        return ans;
    }
};

Java version

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        int n = nums.length, maxsum = 0;
        int[] sum = new int[n+1], posLeft = new int[n], posRight = new int[n], ans = new int[3];
        for (int i = 0; i < n; i++) sum[i+1] = sum[i]+nums[i];
        // DP for starting index of the left max sum interval
        for (int i = k, tot = sum[k]-sum[0]; i < n; i++) {
            if (sum[i+1]-sum[i+1-k] > tot) {
                posLeft[i] = i+1-k;
                tot = sum[i+1]-sum[i+1-k];
            }
            else
                posLeft[i] = posLeft[i-1];
        }
        // DP for starting index of the right max sum interval
        posRight[n-k] = n-k;
        for (int i = n-k-1, tot = sum[n]-sum[n-k]; i >= 0; i--) {
            if (sum[i+k]-sum[i] > tot) {
                posRight[i] = i;
                tot = sum[i+k]-sum[i];
            }
            else
                posRight[i] = posRight[i+1];
        }
        // test all possible middle interval
        for (int i = k; i <= n-2*k; i++) {
            int l = posLeft[i-1], r = posRight[i+k];
            int tot = (sum[i+k]-sum[i]) + (sum[l+k]-sum[l]) + (sum[r+k]-sum[r]);
            if (tot > maxsum) {
                maxsum = tot;
                ans[0] = l; ans[1] = i; ans[2] = r;
            }
        }
        return ans;