64. 最小路径和

题目

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-path-sum

代码及分析

方法一：动态规划法（二维）

该问题可以通过动态规划的方法进行求解，动态规划最主要的是将其动态转移方程写出来。
由于该每次只能向下和向右移动，故可以知道，对于位置m,n处，到达该点只能通过位置m,n-1处以及位置m-1,n处，故最小的路径应为二者较小值加当前位置的值，定义dp[i][j]为位置i,j处的最小路径和，则有dp[i][j] = grid[i-1][j-1] + min(dp[i-1][j],dp[i][j-1]).
初始条件：dp[1][j] = grid[0][j-1] +dp[1][j-1] dp[i][1] = grid[i-1][0] +dp[i-1][1]

  int minPathSum(vector<vector<int>>& grid) {
        if(grid.empty())
            return 0;
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        for(int i = 1; i <= m; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                if(i == 1)
                    dp[i][j] = grid[i-1][j-1] +dp[i][j-1];
                else if(j == 1)
                    dp[i][j] = grid[i-1][j-1] +dp[i-1][j];
                else
                    dp[i][j] = grid[i-1][j-1] + min(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[m][n];
    }

复杂度：

时间复杂度： O(mn) 。
空间复杂度： O(mn) 。

方法二：动态规划法（一维）

对于动态规划问题一般二维的动态转移矩阵可以设法考虑是否可以转换为一维数组。
上述方法一中动态转移方程为dp[i][j] = grid[i-1][j-1] + min(dp[i-1][j],dp[i][j-1])，每一次循环中，i仅与i-1有关，故可以写成dp[j] = grid[i-1][j-1] + min(dp[j],dp[j-1])。

int minPathSum(vector<vector<int>>& grid) {
        if(grid.empty())
            return 0;
        int m = grid.size();
        int n = grid[0].size();
        vector<int> dp(n+1,0);
        for(int i = 1; i <= m; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                if(i == 1)
                    dp[j] = grid[i-1][j-1] +dp[j-1];
                else if(j == 1)
                    dp[j] = grid[i-1][j-1] +dp[j];
                else
                    dp[j] = grid[i-1][j-1] + min(dp[j],dp[j-1]);
            }
        }
        return dp[n];
    }

复杂度：

时间复杂度： O(mn) ；
空间复杂度： O(n) 。

方法三：动态规划法（空间复杂度为O（1））

为了节省空间，我们还可以直接在grid矩阵上进行状态转移。

int minPathSum(vector<vector<int>>& grid) {
        if(grid.empty())
            return 0;
        int m = grid.size();
        int n = grid[0].size();
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(i == 0 && j == 0)
                    continue;
                else if(i == 0)
                    grid[0][j] += grid[0][j-1];
                else if(j == 0)
                    grid[i][0] += grid[i-1][0];
                else
                    grid[i][j] += min(grid[i-1][j],grid[i][j-1]);
            }
        }
        return grid[m-1][n-1];
    }

复杂度：

时间复杂度： O(mn) ；
空间复杂度： O(1) 。