（算法）最⼩路径和————＜动态规划＞

1. 题⽬链接：64.最⼩路径和

2. 题⽬描述：

3. 解法（动态规划）：

算法思路：

像这种表格形式的动态规划，是⾮常容易得到「状态表⽰」以及「状态转移⽅程」的，可以归结到 「不同路径」⼀类的题⾥⾯。

1. 状态表⽰：

对于这种路径类的问题，我们的状态表⽰⼀般有两种形式：

        i. 从[i, j] 位置出发，巴拉巴拉；

        ii. 从起始位置出发，到达[i, j] 位置，巴拉巴拉。

这⾥选择第⼆种定义状态表⽰的⽅式： dp[i][j] 表⽰：到达[i, j] 位置处，最⼩路径和是多少。

2. 状态转移：

简单分析⼀下。如果dp[i][j] 表⽰到达到达[i, j] 位置处的最⼩路径和，那么到达[i, j] 位置之前的⼀⼩步，有两种情况：

        i. 从[i - 1, j] 向下⾛⼀步，转移到[i, j] 位置；

        ii. 从[i, j - 1] 向右⾛⼀步，转移到[i, j] 位置。

由于到[i, j] 位置两种情况，并且我们要找的是最⼩路径，因此只需要这两种情况下的最⼩ 值，再加上 [i, j] 位置上本⾝的值即可。 也就是： dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]

3. 初始化：

可以在最前⾯加上⼀个「辅助结点」，帮助我们初始化。使⽤这种技巧要注意两个点：

        i. 辅助结点⾥⾯的值要「保证后续填表是正确的」；

        ii. 「下标的映射关系」。

在本题中，「添加⼀⾏」，并且「添加⼀列」后，所有位置的值可以初始化为⽆穷⼤，然后让 dp[0][1] = dp[1][0] = 1 即可。

4. 填表顺序：

根据「状态转移⽅程」的推导来看，填表的顺序就是「从上往下」填每⼀⾏，每⼀⾏「从左往 后」。

5. 返回值：

根据「状态表⽰」，我们要返回的结果是dp[m][n] 。

C++算法代码：

class Solution 
{
public:
    int minPathSum(vector<vector<int>>& grid) 
    {
        int m=grid.size(),n=grid[0].size();
        //建表
        vector<vector<int>>dp(m+1,vector<int>(n+1,INT_MAX));
        //初始化
        dp[0][1]=0;
        //填表
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i-1][j-1];
            }
        }
        //返回值
        return dp[m][n];
    }
};

Java算法代码：

class Solution
{
	public int minPathSum(int[][] grid)
	{
		// 1. 创建 dp 表 
		// 2. 初始化 
		// 3. 填表 
		// 4. 返回值 
		int m = grid.length, n = grid[0].length;
		int[][] dp = new int[m + 1][n + 1];
		for (int j = 0; j <= n; j++) dp[0][j] = Integer.MAX_VALUE;
		for (int i = 0; i <= m; i++) dp[i][0] = Integer.MAX_VALUE;
		dp[0][1] = dp[1][0] = 0;
		for (int i = 1; i <= m; i++)
			for (int j = 1; j <= n; j++)
				dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i - 1]
				[j - 1];
		return dp[m][n];
	}
}