动态规划经典题型：最小路径和、所有路径

题目1：最小路径和

给定一个包含非负整数的 *m* x *n* 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

解题思路：

1.dp[i][j] 代表从0，0位置到达ij位置的最小路径和 

2.将矩阵分为上边界、左边界、其余元素

3.矩阵左边界的元素只能由上一个元素向下走得来，dp[i][0]=dp[i-1][0]+grid[i][0];

  矩阵上边界的元素只能由左一个元素向右走得来，dp[0][i]=dp[0][i-1]+grid[0][i];

4.其余元素的走法是选择左边或上边元素中最小的路径，dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];

5.初始值为矩阵左上角元素 ，dp[0][0]=grid[0][0];

源代码如下：

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size();//行大小
        int n=grid[0].size();//列大小
        vector<vector<int>> dp(m,vector<int>(n));//定义二维数组
        //dp[i][j] 代表从0，0位置到达ij位置的最小路径和
        dp[0][0]=grid[0][0];//初始值为矩阵左上角的元素
        //遇到矩阵左边界，只能由上一个元素向下走得来
        for(int i=1;i<m;i++)
        {
            dp[i][0]=dp[i-1][0]+grid[i][0];
        }
        //遇到矩阵上边界，只能由左边的元素往右走得来
        for(int i=1;i<n;i++)
        {
            dp[0][i]=dp[0][i-1]+grid[0][i];
        }
        //其余元素需要判断上边元素和左边元素的大小，选择小的那个元素的路径
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        //返回矩阵右下角的元素即可
        return dp[m-1][n-1];
    }
};

题目2：不同路径（求到达右下角的所有路径）

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例：

 解题思路：

1.dp[i][j]代表从0，0走到i，j的位置有多少条路径

2.矩阵的左边界和上边界只能是一种走法，要么只能向下走，要么只能向右走

dp[i][0]=1;dp[0][i]=1;

3.到达矩阵其余元素的所有路径可以从上一个元素得来，也可以从左一个元素得来，这里我们求的是到达i,j位置的所有路径之和，所以我们只需要将上边和左边的路径相加即可

dp[i][j]=dp[i][j-1]+dp[i-1][j];

源代码如下：

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m,vector<int>(n));//二维数组dp
        //矩阵左边界只有一种走法，只能向下走
        for(int i=0;i<m;i++)
        {
            dp[i][0]=1;
        }
        //矩阵上边界只有一种走法，只能向右走
        for(int i=0;i<n;i++)
        {
            dp[0][i]=1;
        }
        //dp[i][j]代表从0，0走到i，j的位置有多少条路径
        //dp[i][j]要么是从上一个元素向下走得来，要么是左边一个元素向右走得来
        //所以dp[i][j]=dp[i][j-1]+dp[i-1][j];
        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=dp[i][j-1]+dp[i-1][j];
            }
        }
        return dp[m-1][n-1];
    }
};