算法--最小路径和

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

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

示例 1：

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

输入：grid = [[1,2,3],[4,5,6]]
输出：12

问题描述

在一个 m x n 的二维网格 grid 中，从左上角出发，每次只能向右或向下移动，找到到达右下角的路径，使得路径上的数字之和最小。

动态规划解法

实现步骤
初始化 DP 数组：创建一个与原网格大小相同的二维数组 dp，用于存储每个位置的最小路径和。

处理边界条件：

起点 dp[0][0] 初始化为 grid[0][0]。

第一行的每个位置只能从左边到达。

第一列的每个位置只能从上方到达。

填充其他位置：对于非边界的每个位置 (i, j)，其最小路径和为当前值加上上方或左方的最小值。

返回结果：dp 数组右下角的值即为答案。

实际就是一直贪心去找最小的相加

package main

import "fmt"

func minPathSum(grid [][]int) int {
    if len(grid) == 0 || len(grid[0]) == 0 {
        return 0
    }
    
    m, n := len(grid), len(grid[0])
    dp := make([][]int, m)
    for i := range dp {
        dp[i] = make([]int, n)
    }
    
    // 初始化起点
    dp[0][0] = grid[0][0]
    
    // 初始化第一行
    for j := 1; j < n; j++ {
        dp[0][j] = dp[0][j-1] + grid[0][j]
    }
    
    // 初始化第一列
    for i := 1; i < m; i++ {
        dp[i][0] = dp[i-1][0] + grid[i][0]
    }
    
    // 填充其余位置
    for i := 1; i < m; i++ {
        for j := 1; j < n; j++ {
            dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1])
        }
    }
    
    return dp[m-1][n-1]
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func main() {
    grid := [][]int{
        {1, 3, 1},
        {1, 5, 1},
        {4, 2, 1},
    }
    fmt.Println("最小路径和:", minPathSum(grid)) // 输出: 7
}

关键点说明

边界处理：第一行和第一列需要单独初始化。

状态转移：每个位置的最小路径和由上方或左方的最小值决定。

时间复杂度：O(mn)，遍历整个网格一次。

空间复杂度：标准版 O(mn)，优化版 O(1)（直接修改原数组）。

通过这种动态规划方法，可以高效地解决最小路径和问题。