动态规划路径问题

Posted 桃陉

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了动态规划路径问题相关的知识，希望对你有一定的参考价值。

目录

1. 不同路径

1.1 题目

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

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

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

∙ \\bullet ∙ 示例 1：

输入：m = 3, n = 7
输出：28

∙ \\bullet ∙ 示例 2：
输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。

  1. 向右 -> 向下 -> 向下
  2. 向下 -> 向下 -> 向右
  3. 向下 -> 向右 -> 向下

∙ \\bullet ∙ 示例 3：
输入：m = 7, n = 3
输出：28

∙ \\bullet ∙ 示例 4：
输入：m = 3, n = 3
输出：6

提示：

∙ \\bullet ∙ 1 <= m, n <= 100
∙ \\bullet ∙ 题目数据保证答案小于等于 2 * 109

来源：力扣（LeetCode）
链接：题目来源

1.2 分析

∙ \\bullet ∙ 我们生成一个与网格等大的数组dp，dp[i,j] 表示机器到到达 (i,j) 的不同路径数，最后返回 dp[m-1][n-1]。

∙ \\bullet ∙ 对于第一行和第一列来说，每个网格只有一种方法可以到达，也就是一直向左或者一直向右，所以我们在初始化数组时直接给每个网格初始化为1。

∙ \\bullet ∙ 接下来我们就可以从第二行第二列进行数组填充，对于每一个位置（i,j）来说，都可以由左边或者上边到达，那么路径总数也就是左边一格的路径总数加上边一格的路径总数。
d p [ i ] [ j ] = d p [ i − 1 ] [ j ] + d p [ i ] [ j − 1 ] dp[i][j] = dp[i-1][j]+dp[i][j-1] dp[i][j]=dp[i−1][j]+dp[i][j−1]

1.3 代码

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>>dp(m,vector<int>(n,1));

        // for(int i=0;i<m;i++) dp[i][0]=1;
        // for(int i=0;i<n;i++) dp[0][i]=1;

        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

2. 不同路径II

2.1 题目

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

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

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

∙ \\bullet ∙ 示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：

  1. 向右 -> 向右 -> 向下 -> 向下
  2. 向下 -> 向下 -> 向右 -> 向右

∙ \\bullet ∙ 示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

∙ \\bullet ∙ m == obstacleGrid.length
∙ \\bullet ∙ n == obstacleGrid[i].length
∙ \\bullet ∙ 1 <= m, n <= 100
∙ \\bullet ∙ obstacleGrid[i][j] 为 0 或 1

来源：力扣（LeetCode）
链接：题目来源

2.2 分析

∙ \\bullet ∙ 同样我们使用与网格等大的数组dp来记录每个位置的路径总数，最后返回dp数组中最后一个元素。

∙ \\bullet ∙ 我们首先对数组进行初始化，先将dp数组整体初始化为0。因为第一行和第一列只能向左或者向下到达，所以我们需要单独对其初始化。对于第一行和第一列我们按顺序从前往后进行搜索，如果该位置没有障碍物我们依此置1，当遇到第一个障碍物以后就直接跳出循环，因为后面的位置已经无法到达。

∙ \\bullet ∙ 对于其他位置来说，如果没有障碍物，每个位置的路径总数都等于左边的路径总数加上边的路径总数，否则该位置的路径总数就为0，所以状态转移方程为：

d p [ i ] [ j ] = {  0  ( o b s t a c l e G r i d [ i ] [ j ] = 1 )  dp[i-1][j]+dp[i][j-1]  ( o b s t a c l e G r i d [ i ] [ j ] = 0 ) dp[i][j]=\\begin{cases} & \\text{ 0 } (obstacleGrid[i][j]=1) \\\\ & \\text{ dp[i-1][j]+dp[i][j-1] } (obstacleGrid[i][j]=0) \\end{cases} dp[i][j]={​ 0 (obstacleGrid[i][j]=1) dp[i-1][j]+dp[i][j-1] (obstacleGrid[i][j]=0)​

2.3代码

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<int>>dp(m,vector<int>(n,0));

        for(int i=0;i<m;i++)
        {
            if(!obstacleGrid[i][0]) dp[i][0]=1;
            else break;
        }

        for(int j=0;j<n;j++)
        {
            if(!obstacleGrid[0][j]) dp[0][j]=1;
            else break;
        }

        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                if(!obstacleGrid[i][j]) dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }

        return dp[m-1][n-1];
    }
};

3. 最小路径和

3.1 题目

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

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

∙ \\bullet ∙ 示例 1：

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

∙ \\bullet ∙ 示例 2：
输入：grid = [[1,2,3],[4,5,6]]
输出：12

提示：

∙ \\bullet ∙ m == grid.length
∙ \\bullet ∙ n == grid[i].length
∙ \\bullet ∙ 1 <= m, n <= 200
∙ \\bullet ∙ 0 <= grid[i][j] <= 100

来源：力扣（LeetCode）
链接：题目来源

3.2 分析

∙ \\bullet ∙ 对于本题，因为每次操作都需要加每个位置的值，所以我们可以直接在原数组上操作来节省空间开支。

∙ \\bullet ∙ 同样第一行和第一列是特例，每个位置的值都等于前边路径总和加该位置的值：

{  grid[i][0]+=grid[i-1][0]  ( i > = 1 )  grid[0][j]+=grid[0][j-1]  ( j > = 1 ) \\begin{cases} & \\text{ grid[i][0]+=grid[i-1][0] } (i>=1) \\\\ & \\text{ grid[0][j]+=grid[0][j-1] } (j>=1) \\end{cases} {​ grid[i][0]+=grid[i-1][0] (i>=1) grid[0][j]+=grid[0][j-1] (j>=1)​

∙ \\bullet ∙ 对于其他位置来说，只需要取左边和上边的较小值加上该位置的值即可：
g r i d [ i ] [ j ] + = m i n ( g r i d [ i − 1 ] [ j ] , g r i d [ i ] [ j − 1 ] ) grid[i][j]+=min(grid[i-1][j],grid[i][j-1]) grid[i][j]+=min(grid[i−1][j],grid[i][j−1])

3.3 代码

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();

        for(int i=1;i<m;i++)
        {
            grid[i][0]+=grid[i-1][0];
        }
        for(int j=1;j<n;j++)
        {
            grid[0][j]+=grid[0][j-1];
        }

        for(int i=1;i<m;i++)
        {
            for(int j=1;j<n;j++)
            {
                grid[i][j]+=min(grid[i-1][j],grid[i][j-1]);
            }
        }
        return grid[m-1][n-1];
    }
};

4. 三角形最短路径和

4.1 题目

给定一个三角形 triangle ，找出自顶向下的最小路径和。

每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

∙ \\bullet ∙ 示例 1：
输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
输出：11
解释：如下面简图所示：
    2
  3 4
 6 5 7
4 1 8 3
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

∙ \\bullet ∙ 示例 2：
输入：triangle = [[-10]]
输出：-10

提示：

∙ \\bullet ∙ 1 <= triangle.length <= 200
∙ \\bullet ∙ triangle[0].length == 1
∙ \\bullet ∙ triangle[i].length == triangle[i - 1].length + 1
∙ \\bullet ∙ -104 <= triangle[i][j] <= 104

来源：力扣（LeetCode）
链接：题目分析

4.2 分析

∙ \\bullet ∙ 首先来看一下题，题中说明了 t r i a n g l e [ i ] [ j ] triangle[i][j] triangle[i][j] 可以由 t r i a n g l e [ i − 1 ] [ j ] triangle[i-1][j] triangle[i−1][j] 和 t r i a n g l e [ i − 1 ] [ j − 1 ] triangle[i-1][j-1] triangle[i−1][j−1] 下移而来，而对于两边的位置，只能由上一个值下移而来。

∙ \\bullet ∙ 所以我们对于两边需要特殊处理：
{  triangle[i][0]+=triangle[i-1][0];   triangle[i][i]+=triangle[i-1][i-1]; \\begin{cases} & \\text{ triangle[i][0]+=triangle[i-1][0]; } \\\\ & \\text{ triangle[i][i]+=triangle[i-1][i-1];} \\end{cases} {​ triangle[i][0]+=triangle[i-1][0];  triangle[i][i]+=triangle[i-1][i-1];​

∙ \\bullet ∙ 而对于剩下的位置，只需要去上边两个数的较小值与本身

以上是关于动态规划路径问题的主要内容，如果未能解决你的问题，请参考以下文章

算法动态规划 ③ ( LeetCode 62.不同路径 | 问题分析 | 自顶向下的动态规划 | 自底向上的动态规划 )

算法动态规划 ③ ( LeetCode 62.不同路径 | 问题分析 | 自顶向下的动态规划 | 自底向上的动态规划 )

动态规划路径问题

Leetcode-不同路径I和II（计数型动态规划）

Leetcode-不同路径I和II（计数型动态规划）

Leetcode-不同路径I和II（计数型动态规划）