# 1031. Maximum Sum of Two Non-Overlapping Subarrays | Leetcode Solution

## 1031. Maximum Sum of Two Non-Overlapping Subarrays | Leetcode Solution

Given an integer array `nums` and two integers `firstLen` and `secondLen`, return the maximum sum of elements in two non-overlapping subarrays with lengths `firstLen` and `secondLen`.

The array with length `firstLen` could occur before or after the array with length `secondLen`, but they have to be non-overlapping.

subarray is a contiguous part of an array.

Example 1:

```Input: nums = [0,6,5,2,2,5,1,9,4], firstLen = 1, secondLen = 2
Output: 20
Explanation: One choice of subarrays is  with length 1, and [6,5] with length 2.
```

Example 2:

```Input: nums = [3,8,1,3,2,1,8,9,0], firstLen = 3, secondLen = 2
Output: 29
Explanation: One choice of subarrays is [3,8,1] with length 3, and [8,9] with length 2.
```

Example 3:

```Input: nums = [2,1,5,6,0,9,5,0,3,8], firstLen = 4, secondLen = 3
Output: 31
Explanation: One choice of subarrays is [5,6,0,9] with length 4, and [0,3,8] with length 3.
```

Constraints:

• `1 <= firstLen, secondLen <= 1000`
• `2 <= firstLen + secondLen <= 1000`
• `firstLen + secondLen <= nums.length <= 1000`
• `0 <= nums[i] <= 1000`
class Solution {
public:
int helper(vector<int>&nums,int x,int y){
int n=nums.size();
vector<int>pre(n);
vector<int>next(n);
int sum=0;
for(int i=0; i<n; i++){
if(i<x){
sum+=nums[i];
pre[i]=sum;
}
else{
sum+=nums[i]-nums[i-x];
pre[i]=max(sum,pre[i-1]);
}
}
sum=0;
for(int i=n-1; i>=0; i--){
if(i+y>=n){
sum+=nums[i];
next[i]=sum;
}
else{
sum+=nums[i]-nums[i+y];
next[i]=max(sum,next[i+1]);
}
}
int ans=0;
for(int i=0; i<n-1; i++){
ans=max(ans,pre[i]+next[i+1]);
}
return ans;
}

int maxSumTwoNoOverlap(vector<int>& nums, int firstLen, int secondLen) {
return max(helper(nums,firstLen,secondLen),helper(nums,secondLen,firstLen));
}
};