动态规划篇--代码随想录算法训练营第三十一天| 动态规划理论基础，509. 斐波那契数，70. 爬楼梯，746. 使用最小花费爬楼梯，62.不同路径，63. 不同路径 II

热爱编程的OP

已于 2024-08-23 17:39:38 修改

阅读量574

点赞数 10

分类专栏： leetcode 文章标签：算法动态规划 c++ leetcode

于 2024-08-16 19:51:07 首次发布

本文链接：https://blog.csdn.net/m0_67804957/article/details/141261240

版权

leetcode 专栏收录该内容

49 篇文章 0 订阅

订阅专栏

动态规划理论基础

1、动态规划刷题大纲

2、解题五部曲

1、确定dp数组以及下标的含义

题目要求
经验 + 题目要求
分析问题的过程中，发现重复子问题

2、确定递推公式

3、dp数组如何初始化

保证填表时不越界
存在则赋值，不存在则要保证初始化值不干扰后续判断，如求max时初始化-0x3f3f3f3f

4、确定遍历顺序

从前往后
从后往前

5、返回值

509. 斐波那契数

题目链接：力扣题目链接

讲解视频：

手把手带你入门动态规划 | leetcode：509.斐波那契数

题目描述：

斐波那契数 （通常用 F(n) 表示）形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给定 n ，请计算 F(n) 。

示例 1：

输入：n = 2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1

解题思路：

1. 状态表示：
这道题可以「根据题目的要求」直接定义出状态表示：dp[i] 表示：第 i 个泰波那契数的值。

2. 状态转移方程：
题目已经非常贴心的告诉我们了：dp[i] = dp[i - 1] + dp[i - 2]

3. 初始化：
从我们的递推公式可以看出， dp[i] 在i = 0 以及 i = 1 的时候是没有办法进行推导的，因
为 dp[-2] 或 dp[-1] 不是一个有效的数据。因此我们需要在填表之前，将 0, 1 位置的值初始化。题目中已经告诉我们 dp[0] = 0，dp[1] = 1 。

4. 填表顺序：
毫无疑问是「从左往右」。

5. 返回值：
应该返回 dp[n] 的值。

代码：

class Solution {
public:
    int fib(int n) {
        if(n <= 1) return n;
        vector<int> dp(n+1);
        dp[0] = 0,dp[1] = 1;
        for(int i = 2; i <= n; i++)
            dp[i] = dp[i-1] + dp[i-2];
        return dp[n];
    }
};

70. 爬楼梯

题目链接：. - 力扣（LeetCode）

讲解视频：

带你学透动态规划-爬楼梯|LeetCode:70.爬楼梯）

题目描述：

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

解题思路：

1. 状态表示：
这道题可以根据「经验 + 题目要求」直接定义出状态表示：
第一种：以 i 位置为结尾
dp[i] 表示：到达 i 位置时使用的方法个数。

2. 状态转移方程：
根据最近的一步，分情况讨论：

先到达 i - 1 的位置，接下来走一步走到 i 位置：dp[i - 1]；
先到达 i - 2 的位置，接下来走两步走到 i 位置：dp[i - 2]。

由于我们要求的是有多少种方法，因此状态转移方程就呼之欲出了： dp[i] = dp[i - 1]+ dp[i-2]。（同上边斐波那契数列）

3. 初始化：
从我们的递推公式可以看出，我们需要先初始化 i = 1以及 i = 2 位置的值。容易得到
dp[1] = 1，dp[2] = 2 。

4. 填表顺序：
根据「状态转移方程」可得，遍历的顺序是「从左往右」。

5. 返回值：
根据「状态表示以及题目要求」，需要返回 dp[n] 位置的值。

代码：

class Solution {
public:
    int climbStairs(int n) {
        if(n <= 2) return n;
        vector<int> dp(n+1);
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3; i <= n; i++)
            dp[i] = dp[i-1]+dp[i-2];
        return dp[n];
    }
};

746. 使用最小花费爬楼梯

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划开更了！| LeetCode：746. 使用最小花费爬楼梯

题目描述：

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。请你计算并返回达到楼梯顶部的最低花费。

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。

解题思路：

注意点：在这道题中，数组内的每一下标[0，n-1]表示的都是楼层，而顶楼的位置其实是在n的位置!

1. 状态表示：
这道题可以根据「经验 + 题目要求」直接定义出状态表示：
第一种：以 i 位置为结尾
dp[i] 表示：到达 i 位置时的最小花费。（注意：到达 i 位置的时候， i 位置的钱不需要
算上）

2. 状态转移方程：
根据最近的一步，分情况讨论：

先到达 i - 1 的位置，然后支付 cost[i - 1] ，接下来走一步走到 i 位置：dp[i - 1] + csot[i - 1] ；
先到达 i - 2 的位置，然后支付 cost[i - 2] ，接下来走两步走到 i 位置：dp[i - 2] + csot[i - 2] 。

3. 初始化：
从我们的递推公式可以看出，我们需要先初始化 i = 0 以及 i = 1 位置的值。容易得到
dp[0] = dp[1] = 0 ，因为不需要任何花费，就可以直接站在第 0 层和第 1 层上。

4. 填表顺序：
根据「状态转移方程」可得，遍历的顺序是「从左往右」。

5. 返回值：
根据「状态表示以及题目要求」，需要返回 dp[n] 位置的值。

代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size()+1,0);
        for(int i = 2; i <= cost.size(); i++)
            dp[i] = min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]); 
        return dp.back();
    }
};

62.不同路径

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划中如何初始化很重要！| LeetCode：62.不同路径

题目描述：

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。问总共有多少条不同的路径？

示例 1：

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

解题思路：

1. 状态表示：
对于这种「路径类」的问题，我们的状态表示一般有两种形式：

从 [i, j] 位置出发；
从起始位置出发，到达 [i, j] 位置。

这里选择第二种定义状态表示的方式；

dp[i][j] 表示：走到 [i, j] 位置处，一共有多少种方式。

2. 状态转移方程：
如果 dp[i][j] 表示到达 [i, j] 位置的方法数，那么到达 [i, j] 位置之前的一小步，有两种情况：

从 [i, j] 位置的上方（ [i - 1, j] 的位置）向下走一步，转移到 [i, j] 位置；
从 [i, j] 位置的左方（ [i, j - 1] 的位置）向右走一步，转移到 [i, j] 位置。

由于我们要求的是有多少种方法，因此状态转移方程就呼之欲出了： dp[i][j] = dp[i - 1]
[j] + dp[i][j - 1] 。

3. 初始化：
可以在最前面加上一个「辅助结点」，帮助我们初始化。使用这种技巧要注意两个点：

辅助结点里面的值要「保证后续填表是正确的」；
「下标的映射关系」。

在本题中，「添加一行」，并且「添加一列」后，只需将 dp[0][1] 的位置初始化为 1 即可。

4. 填表顺序：
根据「状态转移方程」的推导来看，填表的顺序就是「从上往下」填每一行，在填写每一行的时候「从左往右」。

5. 返回值：
根据「状态表示」，我们要返回 dp[m][n] 的值。

代码：

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        dp[0][1] = 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][n];
    }
};

63. 不同路径 II

题目链接：. - 力扣（LeetCode）

讲解视频：

动态规划，这次遇到障碍了| LeetCode：63. 不同路径 II

题目描述：

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

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

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

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

示例 1：

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

解题思路：

在上一题（62不同路径）的基础上，添加判断条件，即当该位置有障碍物时，就跳过此位置继续向后遍历

代码：

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