[Swift]LeetCode1140. 石子游戏 II | Stone Game II

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

Alex and Lee continue their games with piles of stones.  There are a number of piles arranged in a row, and each pile has a positive integer number of stones piles[i].  The objective of the game is to end with the most stones. 

Alex and Lee take turns, with Alex starting first.  Initially, M = 1.

On each player's turn, that player can take all the stones in the first X remaining piles, where 1 <= X <= 2M.  Then, we set M = max(M, X).

The game continues until all the stones have been taken.

Assuming Alex and Lee play optimally, return the maximum number of stones Alex can get.

Example 1:

Input: piles = [2,7,9,4,4]
Output: 10
Explanation:  If Alex takes one pile at the beginning, Lee takes two piles, then Alex takes 2 piles again. Alex can get 2 + 4 + 4 = 10 piles in total. If Alex takes two piles at the beginning, then Lee can take all three piles left. In this case, Alex get 2 + 7 = 9 piles in total. So we return 10 since it's larger. 

Constraints:

• 1 <= piles.length <= 100
• 1 <= piles[i] <= 10 ^ 4

---

亚历克斯和李继续他们的石子游戏。许多堆石子 排成一行，每堆都有正整数颗石子 piles[i]。游戏以谁手中的石子最多来决出胜负。

亚历克斯和李轮流进行，亚历克斯先开始。最初，M = 1。

在每个玩家的回合中，该玩家可以拿走剩下的 前 X 堆的所有石子，其中 1 <= X <= 2M。然后，令 M = max(M, X)。

游戏一直持续到所有石子都被拿走。

假设亚历克斯和李都发挥出最佳水平，返回亚历克斯可以得到的最大数量的石头。

示例：

输入：piles = [2,7,9,4,4]
输出：10
解释：
如果亚历克斯在开始时拿走一堆石子，李拿走两堆，接着亚历克斯也拿走两堆。在这种情况下，亚历克斯可以拿到 2 + 4 + 4 = 10 颗石子。 
如果亚历克斯在开始时拿走两堆石子，那么李就可以拿走剩下全部三堆石子。在这种情况下，亚历克斯可以拿到 2 + 7 = 9 颗石子。
所以我们返回更大的 10。 

提示：

• 1 <= piles.length <= 100
• 1 <= piles[i] <= 10 ^ 4

---

8ms

class Solution {
    private var sums = [Int](repeating: 0, count: 101)
    private var hash = [[Int]](repeating: [Int](repeating: 0, count: 101), count: 101)
    func stoneGameII(_ piles: [Int]) -> Int {
        let N = piles.count
        if N == 0 { return 0 }
        sums[N-1] = piles[N-1]
        for i in stride(from: N-2, to: -1, by: -1) {
            sums[i] = sums[i+1] + piles[i]
        }
       
        return helper(piles, 0, 1)
    }


    private func helper(_ a: [Int], _ i: Int, _ M: Int) -> Int {
        if i == a.count { return 0 }
        if 2*M >= a.count - i { return sums[i] }
        if hash[i][M] != 0 { return hash[i][M] }

        var minv = Int.max //the min value the next player can get
        for x in 1..<2*M+1 {
            minv = min(minv, helper(a, i+x, max(M,x)))
        }
        hash[i][M] = sums[i] - minv  //max stones = all the left stones - the min stones next player can get
        return hash[i][M]
    }
}

---

Runtime: 16 ms

Memory Usage: 21 MB

class Solution {
    func stoneGameII(_ piles: [Int]) -> Int {
        var n:Int = piles.count
        var sums:[Int] = [Int](repeating:0,count:n + 1)
        for i in stride(from:n - 1,through:0,by:-1)
        {
            sums[i] = piles[i] + sums[i+1]
        }
        var dp:[[Int]] = [[Int]](repeating:[Int](repeating:0,count:n + 1),count:n)
        for i in stride(from:n - 1,through:0,by:-1)
        {
            for j in 1...n
            {
                if 2 * j >= n - i
                {
                    dp[i][j]=sums[i]
                }
                else
                {
                    for k in 1...(2*j)
                    {
                        let nextM:Int = max(k,j)
                        dp[i][j] = max(dp[i][j],sums[i] - dp[i+k][nextM])
                    }
                }
            }
        }
        return dp[0][1]
    }
}

---

20ms 

class Solution {
    func stoneGameII(_ piles: [Int]) -> Int {
        guard !piles.isEmpty else { return 0 }
        
        var hash = [Key:Int]()
        var sums = Array(repeating: 0, count: piles.count)
        sums[0] = piles[0]
        for i in 1..<piles.count {
            sums[i] = sums[i-1] + piles[i]
        }
        return _stoneGameII(sums, 0, 1, &hash)
    }
    
    func _stoneGameII(_ sums: [Int], _ i: Int, _ m: Int, _ hash: inout [Key:Int]) -> Int {
        if i >= sums.count { return 0 }
        
        let key = Key(i,m)
        if let result = hash[key] { return result }
        
        var result = Int.max
        for x in (i..<min(sums.count, (i + m * 2))) {
            result = min(result, _stoneGameII(sums, x+1, max(m, x - i + 1), &hash))
        }
        
        result = sums[sums.count - 1] - (i == 0 ? 0 : sums[i - 1]) - result
        
        hash[key] = result
        return result
    }
}

struct Key: Hashable {
    let i: Int
    let m: Int
    
    init(_ i: Int, _ m: Int) {
        self.i = i
        self.m = m
    }
}

---

40ms

class Solution {
    var m = [[Int]]()
    func stoneGameII(_ piles: [Int]) -> Int {
        var sum = piles.reduce(0){$0 + $1}
        m = [[Int]](repeating:[Int](repeating: Int.min, count: 2 * piles.count), count: piles.count)
        let diff = dfsHelper(piles, 0, 1)
        return (sum - diff) / 2 + diff
    }
    
    fileprivate func dfsHelper(_ piles:[Int], _ idx:Int, _ M:Int) -> Int {
        
        
        if idx >= piles.count {
            return 0
        }
        if m[idx][M] > 0 { return m[idx][M] } 
    
        var sum = 0
        for i in idx...min(idx + 2 * M - 1, piles.count - 1) {
            sum += piles[i]
            m[idx][M] = max(m[idx][M], sum - dfsHelper(piles, i+1, max(M, (i - idx)+1)))
        }
        return m[idx][M]
    }
}

---

192ms

class Solution {
    func stoneGameII(_ piles: [Int]) -> Int {
        guard !piles.isEmpty else { return 0 }
        
        var hash = [Key:Int]()
        return _stoneGameII(piles, 0, 1, true, &hash)
    }
    
    func _stoneGameII(_ piles: [Int], _ i: Int, _ m: Int, _ player: Bool, _ hash: inout [Key:Int]) -> Int {
        if i >= piles.count { return 0 }
        
        let key = Key(i,m,player)
        if let result = hash[key] { return result }
        
        var result = player ? Int.min : Int.max
        for x in (i..<min(piles.count, (i + m * 2))) {
            
            if player { // I am the player, maximize the results
                let sum = piles[i...x].reduce(0,+)
                result = max(result, sum + _stoneGameII(piles, x+1, max(m, x - i + 1), !player, &hash))    
            } 
            else { // I am the opponent, minimize the results
                // Note we don't do "sum + _stoneGame" because we are 
                // only interested in player's result (number of stones)
                result = min(result, _stoneGameII(piles, x+1, max(m, x - i + 1), !player, &hash))    
            }
            
        }
        
        hash[key] = result
        return result
    }
}

struct Key: Hashable {
    let i: Int
    let m: Int
    let player: Bool
    
    init(_ i: Int, _ m: Int, _ player: Bool) {
        self.i = i
        self.m = m
        self.player = player
    }
}