[Leetcode]-64 Minimum Path Sum

刚开始思考用递归来解决该问题：

class Solution {
public:
	int minSum(vector<vector<int> > &grid, int m, int n,int i, int j){
		if(i == m && j == n){
			return  grid[i][j];
		}else if(i == m){
			return grid[i][j] + minSum(grid,m,n,i,j+1);
		}else if(j == n){
			return grid[i][j] + minSum(grid,m,n,i+1,j);
		}
		int right = grid[i][j] + minSum(grid,m,n,i,j+1);
		int down = grid[i][j] + minSum(grid,m,n,i+1,j);
		int min = right < down ? right : down;
		return min;
	}
   int minPathSum(vector<vector<int> >& grid) {
        int m = grid.size()-1;
        int n = grid[0].size()-1;
        return minSum(grid,m,n,0,0);
    }
};

结果运行结果正确，但是超时了

于是参考讨论区别人的做法有更快的解决方案，O(m*n)的时间复杂度，依次求出到每个点的最小路径和，一直到最右下角的格子，算法成功

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