力扣64. 最小路径和（动态规划）

力扣64. 最小路径和（动态规划）

动态规划

由于路径的方向只能是向下或向右，

1. 网格的第一行的每个元素只能从左上角元素开始向右移动到达
2. 网格的第一列的每个元素只能从左上角元素开始向下移动到达，前两点的路径是唯一的，因此每个元素对应的最小路径和即为对应的路径上的数字总和。
3. 对于不在第一行和第一列的元素，可以从其上方相邻元素向下移动一步到达，或者从其左方相邻元素向右移动一步到达，元素对应的最小路径和等于其上方相邻元素与其左方相邻元素两者对应的最小路径和中的最小值加上当前元素的值。

由于每个元素对应的最小路径和与其相邻元素对应的最小路径和有关，因此可以使用动态规划求解。

复杂度分析

• 时间复杂度：O(mn)，其中 m 和 n 分别是网格的行数和列数。需要对整个网格遍历一次，计算 dp 的每个元素的值。
• 空间复杂度：O(mn)，其中 m 和 n 分别是网格的行数和列数。创建一个二维数组 dp，和网格大小相同。

空间复杂度可以优化，例如每次只存储上一行的 \textit{dp}dp 值，则可以将空间复杂度优化到 O(n)O(n)。

//
//  main.cpp
//  minPathSum
//
//  Created by MXQ on 2020/10/21.
//

#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        if (grid.size()==0) {
            return 0;
        }
        if (grid.size()==1 && grid[0].size()==0) {
            return 1;
        }
        if (grid.size()!=1 && grid[0].size()==0) {
            return 0;
        }
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>>f(m,vector<int>(n));
        f[0][0]=grid[0][0];
        for (int i=1; i<m; i++) {
            f[i][0]=f[i-1][0]+grid[i][0];
        }
        for (int j=1; j<n; j++) {
            f[0][j]=f[0][j-1]+grid[0][j];
        }
        for (int i=1; i<m; i++) {
            for (int j=1; j<n; j++) {
                //取左边或者上边较小的，加上本身数字
                f[i][j]=min(f[i-1][j],f[i][j-1])+grid[i][j];
            }
        }
        return f[m-1][n-1];
    }
};

int main(int argc, const char * argv[]) {
    // insert code here...
    Solution s;
    vector<vector<int>> grid(3,vector<int>(3));
    auto result=s.minPathSum(grid);
    std::cout << result<<endl;
    std::cout << "Hello, World!\n";
    return 0;
}