[Swift]LeetCode1031. 两个非重叠子数组的最大和 | Maximum Sum of Two Non-Overlapping Subarrays

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10744670.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given an array A of non-negative integers, return the maximum sum of elements in two non-overlapping (contiguous) subarrays, which have lengths L and M.  (For clarification, the L-length subarray could occur before or after the M-length subarray.)

Formally, return the largest V for which V = (A[i] + A[i+1] + ... + A[i+L-1]) + (A[j] + A[j+1] + ... + A[j+M-1]) and either:

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

Example 1:

Input: A = [0,6,5,2,2,5,1,9,4], L = 1, M = 2
Output: 20
Explanation: One choice of subarrays is [9] with length 1, and [6,5] with length 2.

Example 2:

Input: A = [3,8,1,3,2,1,8,9,0], L = 3, M = 2
Output: 29
Explanation: One choice of subarrays is [3,8,1] with length 3, and [8,9] with length 2.

Example 3:

Input: A = [2,1,5,6,0,9,5,0,3,8], L = 4, M = 3
Output: 31
Explanation: One choice of subarrays is [5,6,0,9] with length 4, and [3,8] with length 3.

Note:

1. L >= 1
2. M >= 1
3. L + M <= A.length <= 1000
4. 0 <= A[i] <= 1000

---

给出非负整数数组 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.

示例 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。

提示：

1. L >= 1
2. M >= 1
3. L + M <= A.length <= 1000
4. 0 <= A[i] <= 1000

---

Runtime: 24 ms

Memory Usage: 19.1 MB

class Solution {
    let N:Int = 1010
    var prefix:[Int] = [Int](repeating:0,count:1010)
    func maxSumTwoNoOverlap(_ A: [Int], _ L: Int, _ M: Int) -> Int {
        var n:Int = A.count
        for i in 1...n
        {
            prefix[i] = prefix[i - 1] + A[i - 1]
        }
        var ans:Int = 0
        var best_l:Int = 0
        for i in (L + M)...n
        {
            best_l = max(best_l, prefix[i - M] - prefix[i - M - L])
            ans = max(ans, best_l + prefix[i] - prefix[i - M])
        }
        var best_m:Int = 0
        for i in (L + M)...n
        {
            best_m = max(best_m, prefix[i - L] - prefix[i - M - L])
            ans = max(ans, best_m + prefix[i] - prefix[i - L])
        }
        return ans        
    }
}

---

24ms 

class Solution {
    func maxSumTwoNoOverlap(_ A: [Int], _ L: Int, _ M: Int) -> Int {
        var leftMax = [Int](repeating: 0, count: A.count)
        var curMax = 0, curSum = 0
        for i in A.indices {
            curSum += i < M ?  A[i] : A[i] - A[i-M]
            curMax = max(curMax, curSum)
            leftMax[i] = curMax
        }

        var rightMax = [Int](repeating: 0, count: A.count+1)
        var i = A.count - 1, ans = 0
        curMax = 0; curSum = 0
        while i >= 0 {
            curSum += (i + M > A.count - 1) ? A[i] : A[i] - A[i+M]
            curMax = max(curMax, curSum)
            rightMax[i] = curMax
            i -= 1
        }

        curSum = 0
        for i in A.indices {
            curSum += i < L ?  A[i] : A[i] - A[i-L]
            let leftMax =  i >= L ? leftMax[i-L] : 0
            ans = max(ans, max(leftMax, rightMax[i+1]) + curSum)
        }
        return ans
    }
}

---

84ms

class Solution {
    func maxSumTwoNoOverlap(_ A: [Int], _ L: Int, _ M: Int) -> Int {
        var sumLs = [Int](repeating: 0, count: A.count)
        var sumMs = [Int](repeating: 0, count: A.count)
        var forwardMaxLs = [Int](repeating: 0, count: A.count)
        var backwardMaxLs = [Int](repeating: 0, count: A.count)
        var forwardMaxMs = [Int](repeating: 0, count: A.count)
        var backwardMaxMs = [Int](repeating: 0, count: A.count)

        var sumL = 0
        var sumM = 0
        for i in 0..<A.count {
            sumL += A[i]
            if i >= L - 1 {
                if i >= L {
                    sumL -= A[i - L]
                }
                sumLs[i] = sumL
            }
            sumM += A[i]
            if i >= M - 1 {
                if i >= M {
                    sumM -= A[i - M]
                }
                sumMs[i] = sumM
            }
        }
        var maxSumL = Int.min
        var maxSumM = Int.min
        for i in 0..<A.count {
            maxSumL = max(maxSumL, sumLs[i])
            forwardMaxLs[i] = maxSumL
            maxSumM = max(maxSumM, sumMs[i])
            forwardMaxMs[i] = maxSumM
        }
        maxSumL = Int.min
        maxSumM = Int.min
        for i in (0..<A.count).reversed() {
            maxSumL = max(maxSumL, sumLs[i])
            backwardMaxLs[i] = maxSumL
            maxSumM = max(maxSumM, sumMs[i])
            backwardMaxMs[i] = maxSumM
        }
        var maxSum = Int.min
        for l in 0..<A.count {
            var m = A.count - 1
            while l <= m - M {
                maxSum = max(maxSum, forwardMaxLs[l] + backwardMaxMs[m])
                m -= 1
            }
        }
        for m in 0..<A.count {
            var l = A.count - 1
            while m <= l - L {
                maxSum = max(maxSum, backwardMaxLs[l] + forwardMaxMs[m])
                l -= 1
            }
        }
        return maxSum
    }
}

---

108ms

class Solution {
    func maxSumTwoNoOverlap(_ A: [Int], _ L: Int, _ M: Int) -> Int {
        var prefixSums: [Int] = [0]
        var sum = 0
        for num in A {
            sum += num
            prefixSums.append(sum)
        }
        var res = 0
        for lRight in L..<prefixSums.count {
            let lSum = prefixSums[lRight] - prefixSums[lRight - L]
            for mRight in stride(from: lRight + M, to: prefixSums.count, by: 1) {
                let mSum = prefixSums[mRight] - prefixSums[mRight - M]
                let total = mSum + lSum
                res = max(res, total)
            }
            
            for mRight in stride(from: M, to: lRight - L, by: 1) {
                let mSum = prefixSums[mRight] - prefixSums[mRight - M]
                let total = mSum + lSum
                res = max(res, total)
            }
        }
        return res
    }
}