最小路径和

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

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

示例:

输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。
看到这一题，第一想法是求2x2的正方形的对角线元素，先一行的求对角线元素的最小路径和，然后在平移正方形再求另一行的正方形对角线的最小路径和，可是会报错，代码如下：

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int n = grid.size();
        if(n==0)
            return 0;
        int m = grid[0].size();
        if(m==0)
            return 0;
        if(n==1){
            int sum;
            for(int i=0;i<m;i++){
                sum += grid[0][i];
            }
            return sum;
        }
        if(m==1){
            int sum1;
            for(int j=0;j<n;j++){
              sum1 += grid[j][0];  
            }
            return sum1;
        }
        int row = grid.size();
        int col = grid[0].size();
        int temp = grid[row-1][col-1];
        for(int i=0;i<row-1;i++){
            for(int j=0;j<col-1;j++){
                grid[i+1][j+1]=min(grid[i][j]+grid[i][j+1]+grid[i+1][j+1], grid[i+1][j+1]+grid[i][j]+grid[i+1][j]);
                grid[0][j+1]=grid[0][j]+grid[0][j+1];
            }
            grid[i+1][0]=grid[i][0]+grid[i+1][0];
            
        }
        int res;
        res = min(temp+grid[row-2][col-1], temp+grid[row-1][col-2]);
        return res;
    }
};

然后就再改正自己的方法，这样，我们将第一行和第一列的数都求他们距离原点的路径和，然后求grid[i][j]=min(grid[i-1][j],grid[i][j-1]);这样依次更新

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int row = grid.size();
        if(row==0)
            return 0;
        int col = grid[0].size();
        if(col==0)
            return 0;
        for(int i=1;i<row;i++){
            grid[i][0] += grid[i-1][0];
        }
        for(int j =1;j<col;j++){
            grid[0][j] += grid[0][j-1];
        }
        for(int i=1;i<row;i++){
            for(int j=1;j<col;j++){
                grid[i][j] += min(grid[i-1][j],grid[i][j-1]);
            }
        }
        return grid[row-1][col-1];
    }
};

这样好的原因就是他的i,j并不是从0开始的恩恩.,当然不是呀，上面第一种方法考虑的是更行grid[i][j]=grid[i-1][j-1]+grid[i-1][j]+grid[i][j-1];
这种方法最致命的缺点是数大的时候溢出
而下面的方法是
先更新原点处的行和列，之后grid[i][j]=grid[i-1][j]+grid[i][j-1];这里面少计算了一个数呀，这才是最精彩的