[Swift]LeetCode813. 最大平均值和的分组 | Largest Sum of Averages

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

We partition a row of numbers A into at most K adjacent (non-empty) groups, then our score is the sum of the average of each group. What is the largest score we can achieve?

Note that our partition must use every number in A, and that scores are not necessarily integers.

Example:
Input: 
A = [9,1,2,3,9]
K = 3
Output: 20
Explanation: 
The best choice is to partition A into [9], [1, 2, 3], [9]. The answer is 9 + (1 + 2 + 3) / 3 + 9 = 20.
We could have also partitioned A into [9, 1], [2], [3, 9], for example.
That partition would lead to a score of 5 + 2 + 6 = 13, which is worse.

Note:

• 1 <= A.length <= 100.
• 1 <= A[i] <= 10000.
• 1 <= K <= A.length.
• Answers within 10^-6 of the correct answer will be accepted as correct.

---

我们将给定的数组 A 分成 K 个相邻的非空子数组 ，我们的分数由每个子数组内的平均值的总和构成。计算我们所能得到的最大分数是多少。

注意我们必须使用 A 数组中的每一个数进行分组，并且分数不一定需要是整数。

示例:
输入: 
A = [9,1,2,3,9]
K = 3
输出: 20
解释: 
A 的最优分组是[9], [1, 2, 3], [9]. 得到的分数是 9 + (1 + 2 + 3) / 3 + 9 = 20.
我们也可以把 A 分成[9, 1], [2], [3, 9].
这样的分组得到的分数为 5 + 2 + 6 = 13, 但不是最大值.

说明:

• 1 <= A.length <= 100.
• 1 <= A[i] <= 10000.
• 1 <= K <= A.length.
• 答案误差在 10^-6 内被视为是正确的。

---

Runtime: 64 ms

Memory Usage: 19.2 MB

class Solution {
    func largestSumOfAverages(_ A: [Int], _ K: Int) -> Double {
        var n:Int = A.count
        var sums:[Double] = [Double](repeating:0,count:n + 1)
        var dp:[Double] = [Double](repeating:0,count:n + 1)
        for i in 0..<n
        {
            sums[i + 1] = sums[i] + Double(A[i])
        }
        for i in 0..<n
        {
            dp[i] = (sums[n] - sums[i]) / Double(n - i)
        }
        for k in 1..<K
        {
            for i in 0..<(n - 1)
            {
                for j in (i + 1)..<n
                {
                    dp[i] = max(dp[i], (sums[j] - sums[i]) / Double(j - i) + dp[j])
                }
            }
        }
        return dp[0]
    }
}

---

92ms

private struct State: Hashable {
    var i: Int
    var K: Int
}

class Solution {
    func largestSumOfAverages(_ A: [Int], _ K: Int) -> Double {
        var dict = [State: Double]()
        return largestSumOfAverages(A, K, 0, &dict)
    }
    
    private func largestSumOfAverages(_ A: [Int], _ K: Int, _ i: Int, _ dict: inout [State: Double]) -> Double {
        guard i < A.count else { return 0 }
        if let val = dict[State(i: i, K: K)] {
            return val
        }
        var sum: Double = 0.0
        var largest: Double = 0.0
        for j in i..<A.count {
            sum += Double(A[j])
            let avg = sum / Double(j - i + 1)
            if K - 1 > 0 {
                largest = max(largest, avg + largestSumOfAverages(A, K - 1, j + 1, &dict))
            }
        }
        largest = max(largest, sum / Double(A.count - i))
        dict[State(i: i, K: K)] = largest
        return largest
    }
}

---

100ms

class Solution {    
    // memo[k][i] 前 i 个 元素分 k 份产生的最大值
    var memo: [[Double]]!
    var sum: [Double]!
    
    func largestSumOfAverages(_ A: [Int], _ K: Int) -> Double {
        let n = A.count
        if n == 0 {
            return 0
        }
        memo = Array(repeating: Array(repeating: 0.0, count: n+1), count: K+1)
        sum = Array(repeating: 0, count: n+1)
        for i in 1...n {
            sum[i] = sum[i-1] + Double(A[i-1])
        }
        return LSA(A, n, K)
    }
    
    func LSA(_ A: [Int], _ n: Int, _ k: Int) -> Double {
        if memo[k][n] > 0 {
            return memo[k][n]
        }
        if k == 1 {
            return sum[n] / Double(n)
        }
        for i in k-1..<n {
            // 总是要分成最后一个和前面几个的, 只是不知道那里是最后一个, 有点像走一步两步的那个思路
            memo[k][n] = max(memo[k][n], LSA(A, i, k-1) + (sum[n] - sum[i]) / Double(n - i))
        }
        return memo[k][n]
    }
}

---

188ms

class Solution {
    func largestSumOfAverages(_ A: [Int], _ K: Int) -> Double {
        var cache = [State: Double]()
        return largestSum(A, K, 0, &cache)
    }
    
    func largestSum(_ A: [Int], _ K: Int, _ index: Int, _ cache: inout [State: Double]) -> Double {
        let count = A.count
        guard count > index else { return 0 }
        var sum: Double = 0
        for i in index..<count { sum += Double(A[i]) }
            
        guard K > 1 else {
            return sum / Double(count - index)
        }
        let state = State(x: K, y: index)
        if let val = cache[state] { return val }
        var mx: Double = 0
        sum = 0
        var totalElements = 0
        for i in index..<count {
            totalElements += 1
            sum += Double(A[i])
            mx = max(mx, sum / Double(totalElements) + largestSum(A, K - 1, i + 1, &cache))
        }
        cache[state] = mx
        return mx
    }
}

struct State: Hashable {
    var x: Int
    var y: Int
}