[leetcode 64] Minimum Path Sum------从左上角到右下角的最小路径值

Question:

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.

分析：

题目意思是一个m*n的矩阵，求从左上角到右下角的最短路径，只能向右走或是向下走。这道题跟机器人从左上角到右下角的路径数目题类似，但是解法不能相同，如果仍旧采用递归法，速度会很慢，超时。

这道题的思路是采用动态规划法分析，需要一个辅助数组，无论在哪个位置，如何走到这个点，都记录如果走到了这个点为止的路径的最小值。

可以知道，如果走第一行或第一列，就是依次与前面的数相加。第i行第j列时候，就要考虑是从上面点走过来的还是从左边点走过来，取其中最小值即可。

最后一个数据即为到右下角时候的路径最小值。

代码如下：

<span style="font-size:14px;">class Solution {
public:
    //vector<int> s;
    //int min = INT_MAX;
public:
    int minPathSum(vector<vector<int>>& grid) {
        if(grid.size() == 0)
            return 0;
        else{
            if(grid[0].size() == 0)
                return 0;
        }
        vector<vector<int>> min_path(grid);
        for(int i = 1; i < grid.size(); ++i){
            min_path[i][0] += min_path[i-1][0];
        }
        for(int i = 1; i < grid[0].size(); ++i){
            min_path[0][i] += min_path[0][i-1];
        }
        for(int i = 1; i < grid.size(); ++i){
            for(int j = 1; j < grid[0].size(); ++j){
                min_path[i][j] += min(min_path[i-1][j],min_path[i][j-1]);
            }
        }
        return min_path[ grid.size()-1][grid[0].size()-1];
        
       
        /*int sum = 0;
        helper(grid,0,0,0,min);
        return min;*/
        
    }
    //递归方法，时间超时
   /* void helper(vector<vector<int>>& grid,int startm,int startn,int sum,int& min){
        if(sum > min){
            return;
        }
        if((grid.size()-startm) == 1){
            for(int i  = startn; i < grid[startm].size(); ++i){
                sum += grid[startm][i];
            }
                if(min > sum)
                    min = sum;
        }
        else{
            if((grid[0].size()-startn) == 1){
                for(int i = startm; i < grid.size(); ++i){
                    sum += grid[i][startn];
                }
                //s.push_back(sum);
                //return sum;
                if(min > sum)
                    min = sum;
            }
            else{
               // int left,down;
               if(grid.size() > startm+1)
                    helper(grid,startm+1,startn,sum+grid[startm][startn],min);
                if(grid[0].size() > startn+1)
                    helper(grid,startm,startn+1,sum+grid[startm][startn],min);
                
            }
        }
    }*/
};</span>