leetcode_p64_MinimumPathSum_cpp

leetcode 第64题：Minimum Path Sum
给定一个m*n的非负整数矩阵，找到一条从左上角到右下角的路径，使得该路径上的数字之和最小。

分析：

要使得和最小，则要求在每个格子上只能向下或向右两种走法。
如果用穷举法，由于所有可能路径为(m-1)+(n-1) = m+n-2种，即m-1步向下走，n-1步向右走，所以所有可能情况为C(m+n-2, m-1)，由于随着m和n的增大，该数会非常大，所以穷举法是不可行的。

所以，考虑用动态规划的方法来解，用一个二维数组dp[i][j]来记录到达(i,j)时的最小路径和。
dp[i,j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
其中：dp[i-1][j] 表示从上方过来；
dp[i][j-1] 表示从左边过来。

初值：
dp[0][0] = grid[0][0]
dp[0][j>0] = grid[0][j-1] //第0行
dp[i>0][0] = grid[i-1][0] //第0列

算法复杂度
时间：O（m*n）
空间：O（m*n）

代码一

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

优化空间复杂度，将二维dp降为一维。

代码二:

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

注意：dp最优时应该为m和n中较小的一个，如果较小的是m，则需要对矩阵进行转置，操作比较麻烦，因此这里使用n作为dp的大小。