[Swift]LeetCode931. 下降路径最小和 | Minimum Falling Path Sum

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

Given a square array of integers A, we want the minimum sum of a falling path through A.

A falling path starts at any element in the first row, and chooses one element from each row.  The next row's choice must be in a column that is different from the previous row's column by at most one.

 Example 1:

Input: [[1,2,3],[4,5,6],[7,8,9]]
Output: 12
Explanation: 
The possible falling paths are:

• [1,4,7], [1,4,8], [1,5,7], [1,5,8], [1,5,9]
• [2,4,7], [2,4,8], [2,5,7], [2,5,8], [2,5,9], [2,6,8], [2,6,9]
• [3,5,7], [3,5,8], [3,5,9], [3,6,8], [3,6,9]

The falling path with the smallest sum is [1,4,7], so the answer is 12.

 Note:

1. 1 <= A.length == A[0].length <= 100
2. -100 <= A[i][j] <= 100

---

给定一个方形整数数组 A，我们想要得到通过 A 的下降路径的最小和。

下降路径可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列。

示例：

输入：[[1,2,3],[4,5,6],[7,8,9]]
输出：12
解释：
可能的下降路径有：

• [1,4,7], [1,4,8], [1,5,7], [1,5,8], [1,5,9]
• [2,4,7], [2,4,8], [2,5,7], [2,5,8], [2,5,9], [2,6,8], [2,6,9]
• [3,5,7], [3,5,8], [3,5,9], [3,6,8], [3,6,9]

和最小的下降路径是 [1,4,7]，所以答案是 12。

 提示：

1. 1 <= A.length == A[0].length <= 100
2. -100 <= A[i][j] <= 100

---

196ms

class Solution {
    func minFallingPathSum(_ A: [[Int]]) -> Int {
        let m:Int = A[0].count
        var dp:[Int] = A[0]
        for j in 0..<(A.count - 1)
        {
            var row:[Int] = A[j]
            var ndp:[Int] = [Int](repeating: Int.max / 2,count: m)
            for i in 0..<m
            {
                for k in -1...1
                {
                    if i+k >= 0 && i+k < m
                    {
                        ndp[i + k] = min(ndp[i + k], dp[i] + A[j + 1][i + k])
                    }
                }
            }
            dp = ndp
        }
        var ret:Int = Int.max
        for v in dp
        {
            ret = min(ret, v)
        }
        return ret
    }
}

---

100ms

class Solution {
    func minFallingPathSum(_ A: [[Int]]) -> Int {
        var currentRow = A[0]
        
        for i in 1..<A.count {
            var nextRow = [Int]()
            let r = A[i]
            for j in 0..<r.count {
                var v = currentRow[j]
                if j > 0 {
                    v = min(v, currentRow[j-1])
                }
                if j+1 < r.count {
                    v = min(v, currentRow[j+1])
                }
                nextRow.append(r[j] + v)
            }
            currentRow = nextRow
        }
        let result = currentRow.reduce(Int.max){min($0, $1)}
        return result
    }
}

---

104ms

class Solution {
    func minFallingPathSum(_ A: [[Int]]) -> Int {
        var dp: [Int] = A[0]
        for i in 1 ..< A.count {
            var pre = Int.max
            for j in 0 ..< A[i].count {
                var cost = 0
                if j == 0 {
                    cost = min(dp[j], dp[j + 1])
                } else if j == A.count - 1 {
                    cost = min(pre, dp[j])
                } else {
                    cost = min(min(pre, dp[j]), dp[j + 1])
                }
                pre = dp[j]
                dp[j] = A[i][j] + cost
            }
        }
        var minCost = Int.max
        for cost in dp {
            minCost = min(minCost, cost)
        }
        return minCost
    }
}

---

108ms

class Solution {
    func minFallingPathSum(_ A: [[Int]]) -> Int {
       var dp = A[0]
        let count = A[0].count
        for i in 1..<A.count{
            var tempDp = [Int](repeating: Int.max, count: count)
            for j in 0..<count{
                for k in max(j-1, 0)...min(j+1, count-1){
                    tempDp[j] = min(tempDp[j], dp[k])
                }
                tempDp[j] += A[i][j]
            }
            dp = tempDp
        }
        return dp.min()!
    }
}

---

120ms

class Solution {
    func minFallingPathSum(_ A: [[Int]]) -> Int {
        guard A.count > 1 else { return minRow(A[0])}
        var mutA = A
        var rowNum = 1
        while rowNum < mutA.count {
            defer { rowNum += 1 }
            for i in (0..<mutA[rowNum].count) {
                let el = mutA[rowNum][i]
                mutA[rowNum][i] = el + mutA[rowNum-1][i]
                if i-1 >= 0 {
                    mutA[rowNum][i] = min(mutA[rowNum][i], el + mutA[rowNum-1][i-1])
                }
                if i+1 < mutA[rowNum].count {
                    mutA[rowNum][i] = min(mutA[rowNum][i], el + mutA[rowNum-1][i+1])
                }
            }
        }
        return minRow(mutA[rowNum-1])
    }
    
    func minRow(_ A: [Int]) -> Int {
        var minEl = Int.max
        for a in A {
            if a < minEl {
                minEl = a
            }
        }
        return minEl
    }
}