[Swift]LeetCode1000. 合并石头的最低成本 | Minimum Cost to Merge Stones

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

There are N piles of stones arranged in a row.  The i-th pile has stones[i] stones.

A move consists of merging exactly K consecutive piles into one pile, and the cost of this move is equal to the total number of stones in these K piles.

Find the minimum cost to merge all piles of stones into one pile.  If it is impossible, return -1.

Example 1:

Input: stones = [3,2,4,1], K = 2
Output: 20
Explanation: 
We start with [3, 2, 4, 1].
We merge [3, 2] for a cost of 5, and we are left with [5, 4, 1].
We merge [4, 1] for a cost of 5, and we are left with [5, 5].
We merge [5, 5] for a cost of 10, and we are left with [10].
The total cost was 20, and this is the minimum possible.

Example 2:

Input: stones = [3,2,4,1], K = 3
Output: -1
Explanation: After any merge operation, there are 2 piles left, and we can't merge anymore.  So the task is impossible.

Example 3:

Input: stones = [3,5,1,2,6], K = 3
Output: 25
Explanation: 
We start with [3, 5, 1, 2, 6].
We merge [5, 1, 2] for a cost of 8, and we are left with [3, 8, 6].
We merge [3, 8, 6] for a cost of 17, and we are left with [17].
The total cost was 25, and this is the minimum possible. 

Note:

• 1 <= stones.length <= 30
• 2 <= K <= 30
• 1 <= stones[i] <= 100

---

有 N 堆石头排成一排，第 i 堆中有 stones[i] 块石头。

每次移动（move）需要将连续的 K 堆石头合并为一堆，而这个移动的成本为这 K 堆石头的总数。

找出把所有石头合并成一堆的最低成本。如果不可能，返回 -1 。 

示例 1：

输入：stones = [3,2,4,1], K = 2
输出：20
解释：
从 [3, 2, 4, 1] 开始。
合并 [3, 2]，成本为 5，剩下 [5, 4, 1]。
合并 [4, 1]，成本为 5，剩下 [5, 5]。
合并 [5, 5]，成本为 10，剩下 [10]。
总成本 20，这是可能的最小值。

示例 2：

输入：stones = [3,2,4,1], K = 3
输出：-1
解释：任何合并操作后，都会剩下 2 堆，我们无法再进行合并。所以这项任务是不可能完成的。.

示例 3：

输入：stones = [3,5,1,2,6], K = 3
输出：25
解释：
从 [3, 5, 1, 2, 6] 开始。
合并 [5, 1, 2]，成本为 8，剩下 [3, 8, 6]。
合并 [3, 8, 6]，成本为 17，剩下 [17]。
总成本 25，这是可能的最小值。 

提示：

• 1 <= stones.length <= 30
• 2 <= K <= 30
• 1 <= stones[i] <= 100

---

32ms

class Solution {
    struct State: Hashable {
        var range: Range<Int>, pileCount: Int
    }
    
    func mergeStones(_ stones: [Int], _ K: Int) -> Int {
        guard (stones.count - 1) % (K - 1) == 0 else {
            return -1
        }
        
        let prefixSum: [Int] = stones.reduce(into: [0]) { $0.append($0.last! + $1) }
        func sum(in range: Range<Int>) -> Int {
            return prefixSum[range.upperBound] - prefixSum[range.lowerBound]
        }
        
        var states: [State: Int] = [:]
        func minCost(in range: Range<Int>, pileCount: Int) -> Int {
            if let result = states[State(range: range, pileCount: pileCount)] {
                return result
            }
            guard range.count != pileCount else {
                return 0
            }
            guard pileCount != 1 else {
                return minCost(in: range, pileCount: K) + sum(in: range)
            }
            
            var result = Int.max
            for split in stride(from: range.lowerBound + 1, to: range.upperBound, by: K - 1) {
                let first = minCost(in: range.lowerBound..<split, pileCount: 1)
                let second = minCost(in: split..<range.upperBound, pileCount: pileCount - 1)
                
                result = min(result, first + second)
            }
            
            states[State(range: range, pileCount: pileCount)] = result
            return result
        }
        
        return minCost(in: stones.indices, pileCount: 1)
    }
}

---

44ms

class Solution {
    private var cache = [[[Int?]]]()
    private var prefixSum = [Int]()
    private var K = 0
    func mergeStones(_ stones: [Int], _ K: Int) -> Int {
        guard stones.count != 1 else { return 0 }
        guard (stones.count - 1) % (K - 1) == 0 else { return -1 }
        guard stones.count >= K else { return -1 }
        
        self.K = K
        
        for i in 0..<stones.count {
            var iArr = [[Int?]]()
            for j in 0..<stones.count {
                var jArr = [Int?]()
                for k in 0...K {
                    if i == j || k == j - i + 1 {
                        jArr.append(0)
                    } else {
                        jArr.append(nil)
                    }
                }
                iArr.append(jArr)
            }
            cache.append(iArr)
        }
        
        prefixSum = [0]
        
        for stone in stones {
            prefixSum.append(prefixSum[prefixSum.count - 1] + stone)
        }
        
        return dp(0, stones.count - 1, 1)
    }
    
    private func dp(_ i: Int, _ j: Int, _ k: Int) -> Int {
        if let val = cache[i][j][k] {
            return val
        }
        
        let result: Int
        
        if k == 1 {
            result = dp(i, j, K) + prefixSum[j + 1] - prefixSum[i]
        } else {
            var minimum = 9999999999999
            var t = i
            while t < j {
                minimum = min(minimum, dp(i, t, 1) + dp(t + 1, j, k - 1))
                t += (K - 1)
            }
            result = minimum
        }
        
        cache[i][j][k] = result
        return result
    }
}

---

Runtime: 380 ms

Memory Usage: 19.3 MB

class Solution {
    func mergeStones(_ stones: [Int], _ K: Int) -> Int {
        var n:Int = stones.count
        var pre:[Int] = [Int](repeating:0,count:n + 1)
        for i in 1...n
        {
            pre[i] = pre[i - 1] + stones[i - 1]
        }
        var inf:Int = 1000000000
        var dp:[[[Int]]] = [[[Int]]](repeating:[[Int]](repeating:[Int](repeating:inf,count:205),count:205),count:205)
        for i in 1...n
        {
            dp[i][i][1] = 0
        }
        for len in 1...n
        {
            var i:Int = 1
            while(i + len - 1 <= n)
            {
                var j:Int = i + len - 1
                if len >= 2
                {
                    for k in 2...len
                    {
                        var t:Int = i
                        while(t + 1 <= j)
                        {
                            dp[i][j][k] = min(dp[i][j][k], dp[i][t][k - 1] + dp[t + 1][j][1])
                            t += 1
                        }
                    }
                }                
                dp[i][j][1] = min(dp[i][j][1], dp[i][j][K] + pre[j] - pre[i - 1])                
                i += 1
            }
        }
        if dp[1][n][1] >= inf
        {
            return -1
        }
        return dp[1][n][1]
    }
}