[Swift]LeetCode64. 最小路径和 | Minimum Path Sum

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

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Example:

Input:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
Output: 7
Explanation: Because the path 1→3→1→1→1 minimizes the sum.

---

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

---

20ms

class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int {
        guard grid.count > 0 else {
            return 0
        }
        let m = grid.count
        let n = grid[0].count
        var dp = Array(repeating:0, count: n)
        dp[0] = grid[0][0]
        for i in 1..<n {
            dp[i] = dp[i - 1] + grid[0][i]
        }
        for i in 1..<m {
            for j in 0..<n {
                if j == 0 {
                    dp[j] += grid[i][0]
                } else {
                    dp[j] = min(dp[j], dp[j - 1]) + grid[i][j]
                }
            }
        }
        return dp[n - 1]
    }
}

---

24ms

class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int {
        guard grid.count>0 else { return 0}
        var rows = grid.count
        var cols = grid[0].count
        var dp = Array(repeating:Array(repeating:0,count:cols),count:rows)
        
        
        dp[0][0] = grid[0][0]
        var row = 0, col = 0
        for row in 1..<rows {
            dp[row][0] = dp[row-1][0] + grid[row][0]
        }
        
        for col in 1..<cols {
            dp[0][col] = dp[0][col-1] + grid[0][col]
        }
        
        for row in 1..<rows {
            for col in 1..<cols {
                dp[row][col] = min(dp[row-1][col],dp[row][col-1]) + grid[row][col]
            }
        }
        
        
        return dp[rows-1][cols-1]
        
    }
}

---

24ms

class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int {
        guard grid.count > 0 else {
            return 0
        }
        var row = [Int].init(repeating: 0, count: grid[0].count+1)
        for i in 1..<row.count {
            row[i] = row[i-1] + grid[0][i-1]
        }
        
        for i in 1..<grid.count {
            row[1] = row[1] + grid[i][0]
            for j in 1..<grid[0].count {
                row[j+1] = row[j] > row[j+1] ? row[j+1] + grid[i][j] : row[j] + grid[i][j]
            }
        }
        let resultIndex = grid[0].count
        return row[resultIndex]
    }
}

---

28ms

class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int {
        var grid = grid
        let m = grid.count
        let n = grid.first!.count
        func top(_ row: Int, _ column: Int) -> Int {
            return row-1 >= 0 ? grid[row-1][column] : 100500
        }
        func left(_ row: Int, _ column: Int) -> Int {
            return column-1 >= 0 ? grid[row][column-1] : 100500
        }
        for row in 0..<m {
            for column in 0..<n {
                if row == 0 && column == 0 { continue }
                grid[row][column] += min(top(row, column), left(row, column))
            }
        }
        return grid.last!.last!
    }
}

---

44ms

class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int { 
        var rows = Array.init(repeating: 0, count: grid[0].count)
        var result = Array.init(repeating: rows, count: grid.count)
        
        result[0][0] = grid[0][0]
        
        for i in 1..<grid.count {
            result[i][0] = grid[i][0] + result[i - 1][0]
        }
        
        for i in 1..<grid[0].count {
            result[0][i] = grid[0][i] + result[0][i - 1]
        }
        
        for row in 1..<grid.count {
            for col in 1..<grid[row].count {
                let a = result[row - 1][col]
                let b = result[row][col - 1]
                
                result[row][col] = min(a, b) + grid[row][col]
            }
        }
     
        return result[grid.count - 1][grid[0].count - 1]
    }
    
    func res(_ row:Int, _ col: Int, _ grid:[[Int]]) -> Int {
        if row == 0 && col == 0 {
            return grid[0][0]
        } else if row == 0 {
            return res(0, col - 1, grid) + grid[row][col]
        } else if col == 0{
            return res(row - 1, 0, grid) + grid[row][col]
        } else {
            let a = res(row - 1, col, grid);
            let b = res(row, col - 1, grid); 
            return min(a, b) + grid[row][col]
        }
    }
}

---

 48ms

class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int {
        var grid = grid
        let n = grid.count
        let m = grid[0].count
        
        for i in 1..<n {
            grid[i][0] += grid[i-1][0]
        }
        
        for j in 1..<m {
            grid[0][j] += grid[0][j-1]
        }
        
        for i in 1..<n {
            for j in 1..<m {
                grid[i][j] += min(grid[i-1][j], grid[i][j-1])
            }
        }
        
        for i in 0..<n {
            for j in 0..<m {
                print(grid[i][j], terminator: " ")
            }
            print()
        }
        
        return grid[n-1][m-1]
    }
}

---

56ms

class Solution {
    func minPathSum(_ grid: [[Int]]) -> Int {
        if grid.count == 0 || grid.first!.count == 0 {
            return 0
        }
        var memo: [Int] = Array(repeating: 0, count: grid.count * grid.first!.count)
        for y in 0..<grid.count {
            for x in 0..<grid.first!.count {
                let value = grid[y][x]
                let index = indexFrom(y, x, grid)
                let topIndex = indexFrom(y - 1, x, grid)
                let leftIndex = indexFrom(y, x - 1, grid)
                if x == 0 && y == 0 {
                    memo[index] = value
                } else if x == 0 { // 第一列, 仅由其上方位置值决定
                    memo[index] = value + memo[topIndex]
                } else if y == 0 { // 第一行, 同理
                    memo[index] = value + memo[leftIndex]
                } else {
                    memo[index] = min(value + memo[leftIndex], value + memo[topIndex])
                }
            }
        }
        
        return memo.last!
    }
    
    /// 二维数组序号转一维数组的Index
    private func indexFrom(_ y: Int, _ x: Int, _ grid: [[Int]]) -> Int {
        return y * grid.first!.count + x
    }
}