[leetcode]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).

思路：

We need to find 3 subarrays

Let's say if I can find the 2nd subarray , then find the largest subarray on both left side and right side, problem solved.

代码：

class Solution {
    public int[] maxSumOfThreeSubarrays(int[] nums, int k) {
        int[] sum = new int[nums.length]; // sum[i] = num[i] + nums[i+1]...+nums[i+k-1];
        int[] lef = new int[nums.length]; // lef[i] = before i, the max sum[];
        int[] rig = new int[nums.length];   // rif[i] = after i, the max sum[];
        int[] IndexL = new int[nums.length];
        int[] IndexR = new int[nums.length];
        int total = 0;
        
        //build sum[]
        for(int i=0; i<nums.length; i++){
            if(i <= k-1){
                total += nums[i];
            }else{
                total = total + nums[i] - nums[i-k];
            }
            if(i-k+1>=0){
                sum[i-k+1] = total;
            }
        }
        
        int max = 0;
        //build lef[]
        for(int i=0; i<=nums.length-k; i++){ //i-k+1 < nums.length -> j < n-k+1
            if(sum[i] > max){
                max = sum[i];
                lef[i] = max;
                IndexL[i] = i;
            }else{
                lef[i] = lef[i-1];
                IndexL[i] = IndexL[i-1];
            }
        }
        max = 0;
        //build rig[]
        for(int i=nums.length-k; i>=0; i--){
            if(sum[i] >= max){
                max = sum[i];
                rig[i] = max;
                IndexR[i] = i;
            }else{
                rig[i] = rig[i+1];
                IndexR[i] = IndexR[i+1];
            }
        }
        // find 2rd subarray;
        total = 0;
        int ret = 0;
        int[] ans = new int[3];
        for(int i=k; i<=nums.length-2*k; i++){ // since no overlap so start with k;
            total = sum[i] + lef[i-k] + rig[i+k]; //i+k <= nums.length-k
            if(total > ret){
                ret = total;
                total = 0;
                ans[0] = IndexL[i-k];
                ans[1] = i;
                ans[2] = IndexR[i+k];
            }
        }
        return ans;
    }
}