一、Problem

给出非负整数数组 A ，返回两个非重叠（连续）子数组中元素的最大和，子数组的长度分别为 L 和 M。（这里需要澄清的是，长为 L 的子数组可以出现在长为 M 的子数组之前或之后。）

从形式上看，返回最大的 V，而 V = (A[i] + A[i+1] + … + A[i+L-1]) + (A[j] + A[j+1] + … + A[j+M-1]) 并满足下列条件之一：

0 <= i < i + L - 1 < j < j + M - 1 < A.length, 或
0 <= j < j + M - 1 < i < i + L - 1 < A.length.

输入：A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2
输出：20
解释：子数组的一种选择中，[9] 长度为 1，[6,5] 长度为 2。

输入：A = [2,1,5,6,0,9,5,0,3,8], L = 4, M = 3
输出：31
解释：子数组的一种选择中，[5,6,0,9] 长度为 4，[0,3,8] 长度为 3。

提示：

• L >= 1
  M >= 1
  L + M <= A.length <= 1000
  0 <= A[i] <= 1000

二、Solution

方法一：分类讨论

对于长度为 L 的窗口，长度为 M 的窗口的位置可能有二：

• 在 L 的左侧
• 在 L 的右侧

对于两种情况我们只取其中的最大值进行计算

class Solution {
    public int maxSumTwoNoOverlap(int[] A, int L, int M) {
        int n = A.length, s[] = new int[n+1];
        for (int i = 1; i <= n; i++)
            s[i] = s[i-1] + A[i-1];

        int ans = 0;
        for (int i = L; i <= n; i++) {
            int maxM = 0;
            for (int j = M; j < i-L; j++) 
                maxM = Math.max(maxM, s[j] - s[j-M]);
            for (int j = i+M; j <= n; j++)
                maxM = Math.max(maxM, s[j] - s[j-M]);
            ans = Math.max(ans, s[i] - s[i-L] + maxM);
        }
        return ans;
    }
}

复杂度分析

• 时间复杂度： O ( n 2 ) O(n^2) O(n2)，
• 空间复杂度： O ( n ) O(n) O(n)，

方法二：优化

基于方法一分类的思想，我们可以不用固定某一种长度的区间然后嵌套地枚举另一种长度的区间，而是两种区间和一起计算，因为长度为 L 和 M 的区间的位置无非就两种，L 左 M 右、M 左 L 右

class Solution {
    public int maxSumTwoNoOverlap(int[] A, int L, int M) {
        int n = A.length, s[] = new int[n+1];
        for (int i = 1; i <= n; i++)
            s[i] = s[i-1] + A[i-1];

        int ans = 0, maxL = 0, maxR = 0;
        for (int i = L; i <= n-M; i++) {
            maxL = Math.max(maxL, s[i] - s[i-L]);
            ans = Math.max(ans, maxL + s[i+M] - s[i]);
        }
        for (int i = M; i <= n-L; i++) {
            maxR = Math.max(maxR, s[i] - s[i-M]);
            ans = Math.max(ans, maxR + s[i+L] - s[i]);
        }
        return ans;
    }
}

复杂度分析

• 时间复杂度： O ( n ) O(n) O(n)，
• 空间复杂度： O ( n ) O(n) O(n)，