【leetcode】Minimum Path Sum

1、题目：

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

2、分析：

（1）递归：minPathSum（[m][n]) =min{ minPathSum（[m-1][n]),minPathSum([m][n-1])} + gird[m][n];

 每一次：原问题都分解为俩个子问题，因此时间复杂度应为：2 + 2^2 + 2^3....;时间复杂度太大。

（2）动态规划：f(m,n)=min{f(m-1,n),f(m,n-1)} + gird[m][n];

动态规划实际是一种迭代法，迭代的每个状态保存在多元数组的一个元素中

3、代码

动态规划法：(参考自：‘http://www.cnblogs.com/remlostime/archive/2012/11/13/2767539.html）

f[i][j] = min(f[i][j-1],f[i-1][j]) + grid[i][j];

class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
        int m = grid.size()-1, n = grid[0].size() - 1; 
        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]=(f[i][j-1] <  f[i-1][j] ? f[i][j-1] : f[i-1][j]) + grid[i][j];
            }
        return f[m][n];
    }
private:
int f[1000][1000];
};

递归法：

class Solution {

public:
    int minPathSum(vector<vector<int> > &grid) {
        return minPathSum2(grid,0,0,grid.size()-1,grid[0].size() - 1);    
    }
private:
int minPathSum2(vector<vector<int> > &grid,int StartX,int StartY,int EndX,int EndY){
if(StartX == EndX){
int sum = 0;
for(int j = StartY;j <= EndY;++j){
sum += grid[StartX][j];
}
return sum;
}else if(StartY == EndY){
int sum = 0;
for(int i = StartX;i <= EndX;++i){
sum += grid[i][StartY];
}
return sum;
}
int sum1 = minPathSum2(grid,StartX + 1,StartY,EndX,EndY);
int sum2 = minPathSum2(grid,StartX,StartY + 1,EndX,EndY);


return grid[StartX][StartY] + (sum1 < sum2 ? sum2 : sum1);
 
}
};