[Swift]LeetCode689. 三个无重叠子数组的最大和 | Maximum Sum of 3 Non-Overlapping Subarrays

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

In a given array nums of positive integers, find three non-overlapping subarrays with maximum sum.

Each subarray will be of size k, and we want to maximize the sum of all 3*k entries.

Return the result as a list of indices representing the starting position of each interval (0-indexed). If there are multiple answers, return the lexicographically smallest one.

Example:

Input: [1,2,1,2,6,7,5,1], 2
Output: [0, 3, 5]
Explanation: Subarrays [1, 2], [2, 6], [7, 5] correspond to the starting indices [0, 3, 5].
We could have also taken [2, 1], but an answer of [1, 3, 5] would be lexicographically larger. 

Note:

• nums.length will be between 1 and 20000.
• nums[i] will be between 1 and 65535.
• k will be between 1 and floor(nums.length / 3).

---

给定数组 nums 由正整数组成，找到三个互不重叠的子数组的最大和。

每个子数组的长度为k，我们要使这3*k个项的和最大化。

返回每个区间起始索引的列表（索引从 0 开始）。如果有多个结果，返回字典序最小的一个。

示例:

输入: [1,2,1,2,6,7,5,1], 2
输出: [0, 3, 5]
解释: 子数组 [1, 2], [2, 6], [7, 5] 对应的起始索引为 [0, 3, 5]。
我们也可以取 [2, 1], 但是结果 [1, 3, 5] 在字典序上更大。

注意:

• nums.length的范围在[1, 20000]之间。
• nums[i]的范围在[1, 65535]之间。
• k的范围在[1, floor(nums.length / 3)]之间。

---

Runtime: 216 ms

Memory Usage: 18.8 MB

class Solution {
    func maxSumOfThreeSubarrays(_ nums: [Int], _ k: Int) -> [Int] {
        var n:Int = nums.count
        var mx:Int = Int.min
        var sums:[Int] = [0]
        var res:[Int] = [Int]()
        var left:[Int] = [Int](repeating:0,count:n)
        var right:[Int] = [Int](repeating:n - k,count:n)
        for num in nums
        {
            sums.append(sums.last! + num)       
        }
        var total:Int = sums[k] - sums[0]
        for i in k..<n
        {
            if sums[i + 1] - sums[i + 1 - k] > total
            {
                left[i] = i + 1 - k
                total = sums[i + 1] - sums[i + 1 - k]
            }
            else
            {
                left[i] = left[i - 1]
            }
        }
        total = sums[n] - sums[n - k]
        for i in stride(from:n - 1 - k,through:0,by:-1)
        {
            if sums[i + k] - sums[i] >= total
            {
                right[i] = i
                total = sums[i + k] - sums[i]
            }
            else
            {
                right[i] = right[i + 1]
            }
        }
        for i in k...(n - 2 * k)
        {
            var l:Int = left[i - 1]
            var r:Int = right[i + k]
            var total:Int = (sums[i + k] - sums[i]) + (sums[l + k] - sums[l]) + (sums[r + k] - sums[r])
            if mx < total
            {
                mx = total
                res = [l, i, r]
            }
        }   
        return res
    }
}

---

220ms

class Solution {
    func maxSumOfThreeSubarrays(_ nums: [Int], _ k: Int) -> [Int] {
        if nums.count < 3 * k { return [Int]() }

        var sums = Array(repeating: 0, count: nums.count - k + 1)
        var s = nums[0..<k].reduce(0, +)
        sums[0] = s
        for i in 1..<sums.count {
            s = s - nums[i - 1] + nums[i + k - 1]
            sums[i] = s
        }
        
        var maxFrom = Array(repeating: 0, count: nums.count - k + 1)
        var idx = maxFrom.count - 1
        for i in (0..<maxFrom.count).reversed() {
            if sums[i] >= sums[idx] {
                idx = i
            }
            maxFrom[i] = idx
        }
        
        var max2From = Array(repeating: (0, 0), count: nums.count - 2 * k + 1)
        var m = 0
        for i in (k..<max2From.count).reversed() {
            let j = maxFrom[i + k]
            let s = sums[i] + sums[j]
            if s >= m {
                m = s
                max2From[i] = (i, j)
            } else {
                max2From[i] = max2From[i + 1]
            }
        }
        
        m = 0
        var res = [0, 0, 0]
        for i in 0..<max2From.count - k {
            let (x, y) = max2From[i + k]
            let s = sums[i] + sums[x] + sums[y]
            if m < s {
                m = s
                res = [i, x, y]
            }
        }
        return res
    }
}

---

228ms

class Solution {
    
    func maxSumOfThreeSubarrays(_ nums: [Int], _ k: Int, _ debugMode: Bool = false) -> [Int] {
        guard nums.count > 1 && k <= (nums.count / 3) else {
            return [0]
        }

        // find the cumulative sum for window of size k
        let n = nums.count

        // compute the cumulative sum from the left
        let leftSum = self.leftSum(nums, k)
        if debugMode {
            print("leftSum: (leftSum)")
        }

        // holds the index in the leftSum array that has the maximum value seen so far from left
        let maxSumLeftIndex = self.maxSumLeftIndex(leftSum)
        if debugMode {
            print("maxSumLeftIndex: (maxSumLeftIndex)")
        }

        // holds the index in the rightSum array that has the maximum value seen so far from right
        let maxSumRightIndex = self.maxSumRightIndex(leftSum)
        if debugMode {
            print("maxSumRightIndex: (maxSumRightIndex)")
        }

        // find the triplet which has sum is maximum
        var result: [Int] = [0, 0, 0]
        var maxSum = Int.min
        for i in (2 * k - 1)..<(n - k) {
            let index1 = maxSumLeftIndex[i - k]
            let index2 = i
            let index3 = maxSumRightIndex[i + k]
            
            let sum1 = leftSum[index1]
            let sum2 = leftSum[index2]
            let sum3 = leftSum[index3]

            let sum = sum1 + sum2 + sum3
            if maxSum < sum {
                maxSum = sum
                result[0] = index1 - k + 1
                result[1] = index2 - k + 1
                result[2] = index3 - k + 1
            }
        }

        return result
    }

    // compute the cumulative sum from the left
    func leftSum(_ nums: [Int], _ k: Int) -> [Int] {
        let n = nums.count
        var leftSum = Array(repeating: 0, count: n)
        var leftRunningSum = (0..<k).reduce(0) { $0 + nums[$1] }
        leftSum[k-1] = leftRunningSum
        for i in k..<n {
            leftRunningSum -= nums[i-k]
            leftRunningSum += nums[i]
            leftSum[i] = leftRunningSum
        }

        return leftSum
    }

    // holds the index in the leftSum array that has the maximum value seen so far from left
    func maxSumLeftIndex(_ leftSum: [Int]) -> [Int] {
        let n = leftSum.count
        var maxSumLeftIndex = Array(repeating: 0, count: n)
        maxSumLeftIndex[0] = 0
        for i in 1..<n {
            if leftSum[i] > leftSum[maxSumLeftIndex[i-1]] {
                maxSumLeftIndex[i] = i
            } else {
                maxSumLeftIndex[i] = maxSumLeftIndex[i-1]
            }
        }

        return maxSumLeftIndex
    }

    // holds the index in the rightSum array that has the maximum value seen so far from right
    func maxSumRightIndex(_ rightSum: [Int]) -> [Int] {
        let n = rightSum.count
        var maxSumRightIndex = Array(repeating: 0, count: n)
        
        maxSumRightIndex[n - 1] = n - 1
        for i in (0..<(n-1)).reversed() {
            if rightSum[i] > rightSum[maxSumRightIndex[i+1]] {
                maxSumRightIndex[i] = i
            } else {
                maxSumRightIndex[i] = maxSumRightIndex[i+1]
            }
        }
        return maxSumRightIndex
    }    
}

---

244ms

class Solution {
    func maxSumOfThreeSubarrays(_ nums: [Int], _ k: Int) -> [Int] {
        if nums.count < k*3 {
            return []
        }
        
        var sum = [Int](repeating: 0, count: nums.count)
        sum[0] = nums[0]
        for i in 1..<nums.count {
            sum[i] = nums[i] + sum[i-1]
        }
        
        var dp = [[Int]](repeating: [Int](repeating: 0, count: nums.count), count: 3)
        var prev = [[Int]](repeating: [Int](repeating: 0, count: nums.count), count: 2)

        for i in k-1..<nums.count {
            dp[0][i] = sum[i]
            if i >= k {
                dp[0][i] -= sum[i-k]
            }
        }
        
        
        var maxSum = Int.min
        var maxIndex = -1
        for i in 1...2 {
            var maxPrevSum = Int.min
            var maxPrevIndex = -1

            for j in k*(i+1)-1..<nums.count {
                if dp[i-1][j-k] > maxPrevSum {
                    maxPrevSum = dp[i-1][j-k]
                    maxPrevIndex = j-k
                }
                prev[i-1][j] = maxPrevIndex
                dp[i][j] = maxPrevSum + sum[j] - sum[j-k]
                
                if i == 2 && dp[i][j] > maxSum {
                    maxSum = dp[i][j]
                    maxIndex = j
                }
            }
            
        }
        
        let second = prev[1][maxIndex]
        let first = prev[0][second]
        return [first-k+1, second-k+1, maxIndex-k+1]
    }
}

---

256ms

class Solution {
    func maxSumOfThreeSubarrays(_ nums: [Int], _ k: Int) -> [Int] {
        // calculate array of k-size subarrays sums
        var sumArray = [Int](repeating: 0, count: nums.count - k + 1)
        var num = 0
        for i in 0..<k {
            num += nums[i]
        }
        sumArray[0] = num
        for i in 1..<sumArray.count {
            num -= nums[i - 1]
            num += nums[i - 1 + k]
            sumArray[i] = num
        }
        //print(sumArray)
        var leftArr = [Int](repeating: 0, count: sumArray.count)
        var best = 0
        for i in 0..<sumArray.count {
            if sumArray[i] > sumArray[best] { best = i }
            leftArr[i] = best
        }
        //print(leftArr)
        var rightArr = [Int](repeating: 0, count: sumArray.count)
        best = sumArray.count - 1
        for i in stride(from: sumArray.count - 1, through: 0, by: -1) {
            if sumArray[i] >= sumArray[best] { best = i }
            rightArr[i] = best
        }
        //print(rightArr)
        var res = [-1, -1, -1]
        for j in k..<sumArray.count - k {
            let i = leftArr[j - k]
            let k = rightArr[j + k]
            let sum = sumArray[i] + sumArray[j] + sumArray[k]
            if res[0] == -1 || sum > res.map({ sumArray[$0] }).reduce(0, +) {
                res[0] = i
                res[1] = j
                res[2] = k
            }
        }
        return res
    }
}

---

356ms

class Solution {
    struct Result: Comparable {
        let sum: Int
        let indicies: [Int]
        
        static func < (lhs: Result, rhs: Result) -> Bool {
            return lhs.sum < rhs.sum
        }
    }
    func maxSumOfThreeSubarrays(_ nums: [Int], _ k: Int) -> [Int] {
        var sum: [[Result]] = Array(repeating: Array(repeating: Result(sum: 0, indicies: []), count: nums.count), count: 4)
        var kNumsSum = 0
        for i in stride(from: nums.count - 1, through: 0, by: -1) {
            kNumsSum += nums[i]
            if i <= nums.count - k {
                if i < nums.count - k {
                    kNumsSum -= nums[i + k]
                }
                sum[1][i] = Result(sum: kNumsSum, indicies: [i])
            }
        }
        var maxResult = Result(sum: 0, indicies: [])
        for j in 2...3 {
            for i in ((j - 1) * k)...(nums.count - k) {
                let prevMaxSum = sum[j][i - 1].sum - sum[1][i - 1].sum
                var prevIndices = sum[j][i - 1].indicies
                if prevIndices.count > 0 {
                    prevIndices.removeLast()
                }
                var result = Result(sum: prevMaxSum, indicies: prevIndices)
                if sum[j - 1][i - k].sum > prevMaxSum {
                    result = sum[j - 1][i - k]
                }
                
                sum[j][i] = Result(sum: result.sum + sum[1][i].sum, 
                                   indicies: result.indicies + [i])
                if j == 3 && maxResult < sum[j][i] {
                    maxResult = sum[j][i]
                }
            }
        }
        return maxResult.indicies
    }
}

---

396ms

class Solution {
    struct Result: Comparable {
        let sum: Int
        let indicies: [Int]
        
        static func < (lhs: Result, rhs: Result) -> Bool {
            return lhs.sum < rhs.sum
        }
        
        static func + (lhs: Result, rhs: Result) -> Result {
            return Result(sum: lhs.sum + rhs.sum, indicies: lhs.indicies + rhs.indicies)
        }
    }
    func maxSumOfThreeSubarrays(_ nums: [Int], _ k: Int) -> [Int] {
        let zeroResult = Result(sum: 0, indicies: [])
        var maxSum: [[Result]] = Array(repeating: Array(repeating: zeroResult, count: 4), count: nums.count)
        
        var sum: [Int] = Array(repeating: 0, count: nums.count)
        var kNumsSum = 0
        
        for i in stride(from: nums.count - 1, through: 0, by: -1) {
            kNumsSum += nums[i]
            if i < nums.count - k {
                kNumsSum -= nums[i + k]
            }
            sum[i] = kNumsSum
        }
        
        for j in 1...3 {
            for i in (j * k - 1)..<nums.count {
                var maxResult = zeroResult
                if i >= k {
                    maxResult = maxSum[i - k][j - 1]
                }
                let lastSubArrayIndex = i - k + 1
                maxResult = Result(sum: maxResult.sum + sum[lastSubArrayIndex], 
                                   indicies: maxResult.indicies + [lastSubArrayIndex])
                if i > 0 && maxSum[i - 1][j] >= maxResult {
                    maxResult = maxSum[i - 1][j]
                }
                maxSum[i][j] = maxResult
            }
        }
        return maxSum[nums.count - 1][3].indicies
    }
}