算法题解——矩阵的最小路径和

题目描述
给定一个 n * m 的矩阵 a，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，输出所有的路径中最小的路径和。

解法一 暴力解法（会超时）
比较所有可以走的路径，选择和最小的路径。
采用递归的方法，限制条件：

1. 在矩阵的右边界只能向下走
2. 在矩阵的下边界只能向右走
3. 在其他地方取向右或者向下最小的路径走

class Solution {
public:
    //暴力递归 超时！！
    int minPathSum(vector<vector<int> >& matrix) {
        int row = matrix.size();
        int cor = matrix[0].size();
        return minPath(matrix,0,0,row,cor);
    }
    int minPath(vector<vector<int> >& matrix,int i,int j,int row,int cor)
    {
        if(i == row-1 && j==cor-1)    //到达右下角
            return matrix[i][j];
        if(i == row-1)    //下边界
            return matrix[i][j] + minPath(matrix,i,j+1,row,cor);
        if(j == cor-1)    //有边界
            return matrix[i][j] + minPath(matrix,i+1,j,row,cor);
        //不在边界
        int right = matrix[i][j] + minPath(matrix,i,j+1,row,cor);
        int down = matrix[i][j] + minPath(matrix,i+1,j,row,cor);
        return min(right,down);
    }
};

解法二 动态规划
建立一个和矩阵大小相同的动态规划表dp[row][cor]，其中dp[i][j]中保存走到(i,j)这一步的最小路径和，
在第一行的时候没有选择，只能是从左边走过来的；
在第一列的时候，只能是从上边走过来的。
在其他位置，选择左边和上边最小的路径走。递推公式为：
dp[i][j] = matrix[i][j] + min(dp[i-1][j],dp[i][j-1])

class Solution {
public:

    int minPathSum(vector<vector<int> >& matrix) {
        int row = matrix.size();
        int col = matrix[0].size();
        vector<vector<int>> dp(row,vector<int>(col,0));
        dp[0][0] = matrix[0][0];    //起点
        //当在第一行走的时候只能从左向右走
        for(int i=1;i<col;i++)
        {
            dp[0][i] = matrix[0][i] + dp[0][i-1];
        }
        //当在第一列走的时候只能从上向下走
        for(int j=1;j<row;j++)
        {
            dp[j][0] = dp[j-1][0] + matrix[j][0];
        }
        for(int i=1;i<row;i++)
        {
            for(int j=1;j<col;j++)
            {
                dp[i][j] = matrix[i][j] + min(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[row-1][col-1];
    }
   
};