LeetCode //C - 1031. Maximum Sum of Two Non-Overlapping Subarrays

1031. Maximum Sum of Two Non-Overlapping Subarrays

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.

A 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 9 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 <= numsi <= 1000

From: LeetCode

Link: 1031. Maximum Sum of Two Non-Overlapping Subarrays

---

Solution:

Ideas:

• Try both orders:
  • firstLen subarray before secondLen
  • secondLen subarray before firstLen
• While scanning, keep:
  • the best sum of the left subarray seen so far
  • combine it with the current right subarray

Code:

int maxSumTwoNoOverlap(int* nums, int numsSize, int firstLen, int secondLen) {
    int prefix[1001] = {0};
    int i;
    
    for (i = 0; i < numsSize; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    int ans = 0;
    
    /* Case 1: firstLen subarray is before secondLen subarray */
    int bestFirst = prefix[firstLen] - prefix[0];
    for (i = firstLen + secondLen; i <= numsSize; i++) {
        int firstSum = prefix[i - secondLen] - prefix[i - secondLen - firstLen];
        if (firstSum > bestFirst) {
            bestFirst = firstSum;
        }
        
        int secondSum = prefix[i] - prefix[i - secondLen];
        int total = bestFirst + secondSum;
        if (total > ans) {
            ans = total;
        }
    }
    
    /* Case 2: secondLen subarray is before firstLen subarray */
    int bestSecond = prefix[secondLen] - prefix[0];
    for (i = firstLen + secondLen; i <= numsSize; i++) {
        int secondSum = prefix[i - firstLen] - prefix[i - firstLen - secondLen];
        if (secondSum > bestSecond) {
            bestSecond = secondSum;
        }
        
        int firstSum = prefix[i] - prefix[i - firstLen];
        int total = bestSecond + firstSum;
        if (total > ans) {
            ans = total;
        }
    }
    
    return ans;
}