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 <= nums[i] <= 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:

c 复制代码

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