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;
}
}