题目描述
给出非负整数数组 A ，返回两个非重叠（连续）子数组中元素的最大和，子数组的长度分别为 L 和 M。（这里需要澄清的是，长为 L 的子数组可以出现在长为 M 的子数组之前或之后。）
示例1
输入：
A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2
输出：
20
解释：
子数组的一种选择中，[9] 长度为 1，[6,5] 长度为 2。
示例2
输入：
A = [3,8,1,3,2,1,8,9,0], L = 3, M = 2
输出：
29
解释：
子数组的一种选择中，[3,8,1] 长度为 3，[8,9] 长度为 2。
示例3
输入：
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
题解
这题意思就是找到两段给定长度的、不重合的、连续的区间，使得两段区间和最大。
因为长度是给定的，所以我们只需要预处理好前缀和 sum ，然后给定区间右端点，就可以直接算出区间和。 那么如果枚举两段区间的右端点，时间复杂度也才 ，极限情况下也就 1e6 左右，貌似也还可以接受。
那有没有更快的方法呢？试试动态规划！因为两段区间有前后顺序，我们不妨假设长度为 L 的区间在后面。 用 dpm[i] 表示前 i 个数中长度为 M 的区间和的最大值。 那么 dpm[i] = max{dpm[i-1], sum[i] - sum[i-M]} ，也就是要么取最后 M 个数，要么最后一个数不取，在前 i - 1 个数里面找答案。 然后 dpm 全部处理完之后，遍历数组，假设长度为 L 的区间以 A[i] 结束，那么我们只需要在 A[0] 到 A[i-L] 中间找长度为 M 的区间最大和就行了，那答案不就是上面求好的 dpm[i-L] 吗？这样最终时间复杂度就是 了。
结束了吗？并没有！空间还能不能优化呢？其实当我们遍历长度为 L 的区间时，长度为 M 的区间不用每次都重新遍历，可以重复利用之前的结果，每次向右移动直到和长度为 L 的区间衔接上为止。这样就等于用了两个指针，分别指向了两个区间的右端点，总共最多移动 2n 次就行了。
代码
动态规划（c++）
class Solution {
public:
static const int N = 1010;
int dpl[N], dpm[N], sum[N];
int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
memset(dpl, 0, sizeof dpl);
memset(dpm, 0, sizeof dpm);
sum[0] = 0;
int n = A.size();
for (int i = 0; i < n; ++i) {
sum[i+1] = sum[i] + A[i];
}
dpl[L] = sum[L];
dpm[M] = sum[M];
int res = 0;
for (int i = 0; i < n; ++i) {
if (i >= L) {
dpl[i+1] = max(dpl[i], sum[i+1] - sum[i+1-L]);
res = max(res, sum[i+1] - sum[i+1-L] + dpm[i+1-L]);
}
if (i >= M) {
dpm[i+1] = max(dpm[i], sum[i+1] - sum[i+1-M]);
res = max(res, sum[i+1] - sum[i+1-M] + dpl[i+1-M]);
}
}
return res;
}
};
动态规划（python）
class Solution:
def maxSumTwoNoOverlap(self, A: List[int], L: int, M: int) -> int:
N = 1010
dpl = [0] * N
dpm = [0] * N
sum = [0] * N
n = len(A)
for i in range(n):
sum[i+1] = sum[i] + A[i]
dpl[L] = sum[L]
dpm[M] = sum[M]
res = 0
for i in range(n):
if i >= L:
dpl[i+1] = max(dpl[i], sum[i+1] - sum[i+1-L])
res = max(res, sum[i+1] - sum[i+1-L] + dpm[i+1-L])
if i >= M:
dpm[i+1] = max(dpm[i], sum[i+1] - sum[i+1-M])
res = max(res, sum[i+1] - sum[i+1-M] + dpl[i+1-M])
return res
指针法（c++）
class Solution {
public:
static const int N = 1010;
int sum[N];
int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
sum[0] = 0;
int n = A.size();
for (int i = 0; i < n; ++i) {
sum[i+1] = sum[i] + A[i];
}
int lmax = 0, mmax = 0, res = 0;
for (int i = L+M; i <= n; ++i) {
lmax = max(lmax, sum[i-M] - sum[i-M-L]);
mmax = max(mmax, sum[i-L] - sum[i-L-M]);
res = max(res, lmax + sum[i] - sum[i-M]);
res = max(res, mmax + sum[i] - sum[i-L]);
}
return res;
}
};
指针法（python）
class Solution:
def maxSumTwoNoOverlap(self, A: List[int], L: int, M: int) -> int:
N = 1010
sum = [0] * N
n = len(A)
for i in range(n):
sum[i+1] = sum[i] + A[i]
lmax = mmax = res = 0
for i in range(L+M, n+1):
lmax = max(lmax, sum[i-M] - sum[i-M-L])
mmax = max(mmax, sum[i-L] - sum[i-L-M])
res = max(res, lmax + sum[i] - sum[i-M])
res = max(res, mmax + sum[i] - sum[i-L])
return res
后记
思考问题要从简单往困难思考，先想想暴力怎么做？再想想怎么优化它。就算做出来了，也不要拘泥于一种解法，还有代码上能否优化？变量、写法上能否更优美一点？
当然很熟练了之后这些都不用考虑了，上来像我一样直接一步到位就行了，嘻嘻。