689. Maximum Sum of 3 Non-Overlapping Subarrays

问题：

给定一个数组，求从中取得3组连续长度为 k 的子数组，使得3组数组和为最大，且使得3组的index尽可能小(★)。

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组子数组，则分别取得左最大，右最大，在遍历中间的所有可能，取得中间最大。

取得最大的方法：sum[nums[i] ～ nums[i+k]]=sum[i+k+1]-sum[i]

1. 因此，首先遍历nums，求得sum[i]=0～i-1的sum

注意：sum[0]=0，为了后续方便做减法，需要0. sum[1]=nums[0], sum[2]=nums[0]+nums[1],...

for(int i=1; i<=n; i++) sum[i]=nums[i-1]+sum[i-1];//0~n+1:{0,sum(0~0),sum(0~1)...}

2.由于最终以中间的子数组为判断对象，其首元素index范围在【k～n-2k】

解释【k～n-2k】：

极端情况：第一个数组取最开头【0～k-1】，那么中间的index最小可能取到 k

最后一个数组取最末尾【n-k～n-1】，那么中间的index最大取到n-k-1，其首元素index为n-k-1-(k-1)=n-2k

【0～k-1】【k～。。。～n-k-1】【n-k～n-1】

那么我们也只需要求的这个范围内的左边最大的各种情况，和右边最大的各种情况。

左边最大：

        tmpmax=-1;
        for(int i=k; i<=n-2*k; i++){
            if(tmpmax<(sum[i]-sum[i-k])){
                tmpmax=sum[i]-sum[i-k];
                leftPos[i]=i-k;
            }else{
                leftPos[i]=leftPos[i-1];
            }
        }

求得中间开始index为 i 时，左边最大情况下的左边数组首元素index

sum[nums[i-k] ～ nums[i-1]]=sum[i]-sum[i-k]

从左往右，如果出现更大的sum，那么到该 i 为止，左边最大的位置应被更新为更大sum的首元素index

若【小于等于】目前最大的sum，那么到该 i 为止，左边最大位置同前一个结果相同。

（由于要使index尽可能小(★)，这里从左向右遍历，所以尽可能【不改变】已经取得的最大值）

右边最大：

        tmpmax=-1;
        for(int i=n-2*k; i>=k; i--){
            if(tmpmax<=(sum[i+2*k]-sum[i+k])){
                tmpmax=sum[i+2*k]-sum[i+k];
                rightPos[i]=i+k;
            }else{
                rightPos[i]=rightPos[i+1];
            }
        }

求得中间开始index为 i 时，右边最大情况下的右边数组首元素index

sum[nums[i+k] ～ nums[i+2*k-1]]=sum[i+2*k]-sum[i+k]

从右往左，如果出现更大的sum，那么到该 i 为止，右边最大的位置应被更新为更大sum的首元素index

若【小于】目前最大的sum，那么到该 i 为止，右边最大位置同前一个结果相同。

（由于要使index尽可能小(★)，这里从右往左遍历，所以尽可能【改变】已经取得的最大值）

3.已有2求的到对应 i 为止，左边可得最大sum的index，和右边可得最大sum的index，

那么，再加上当前 i 的中间之和，为当前 i 的总最大sum

再遍历中间数组的所有可能：【k～n-2k】

取得当前最大：

        tmpmax=-1;
        for(int i=k; i<=n-2*k; i++){
            int l=leftPos[i];
            int r=rightPos[i];
            int tmpsum = (sum[i+k]-sum[i]) + (sum[l+k]-sum[l]) + (sum[r+k]-sum[r]);
            if(tmpsum>tmpmax){
                res={l,i,r};
                tmpmax=tmpsum;
            }
        }

 最终得到的当前最大 res，则为所求。

代码参考：

class Solution {
public:
    vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {
        int n=nums.size();
        int tmpmax=-1;
        vector<int>sum(n+1,0);
        vector<int>leftPos(n,0);
        vector<int>rightPos(n,0);
        vector<int>res(3,0);
        for(int i=1; i<=n; i++) sum[i]=nums[i-1]+sum[i-1];//0~n+1:{0,sum(0~0),sum(0~1)...}
        for(int i=k; i<=n-2*k; i++){
            if(tmpmax<(sum[i]-sum[i-k])){
                tmpmax=sum[i]-sum[i-k];
                leftPos[i]=i-k;
            }else{
                leftPos[i]=leftPos[i-1];
            }
        }
        tmpmax=-1;
        for(int i=n-2*k; i>=k; i--){
            if(tmpmax<=(sum[i+2*k]-sum[i+k])){
                tmpmax=sum[i+2*k]-sum[i+k];
                rightPos[i]=i+k;
            }else{
                rightPos[i]=rightPos[i+1];
            }
        }
        tmpmax=-1;
        for(int i=k; i<=n-2*k; i++){
            int l=leftPos[i];
            int r=rightPos[i];
            int tmpsum = (sum[i+k]-sum[i]) + (sum[l+k]-sum[l]) + (sum[r+k]-sum[r]);
            if(tmpsum>tmpmax){
                res={l,i,r};
                tmpmax=tmpsum;
            }
        }
        return res;
    }
};