动态规划基础题目-代码随想录-刷题笔记

已于 2023-06-05 20:13:01 修改
阅读量762 收藏
点赞数 1
文章标签： 动态规划 笔记 算法 leetcode c++
于 2023-05-29 11:15:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63787588/article/details/130924491
版权

在这里插入图片描述

基础理论

什么是动态规划：Dynamic Programming

动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，
贪心没有状态推导，而是从局部直接选最优的，
记住：动规是由前一个状态推导出来的，而贪心是局部直接选最优

动态规划的解题步骤

  1. 确定dp数组（dp table）以及下标的含义
  2. 确定递推公式
  3. dp数组如何初始化
  4. 确定遍历顺序
  5. 举例推导dp数组

动态规划应该如何debug

找问题的最好方式就是把dp数组打印出来，看看究竟是不是按照自己思路推导的！
做动规的题目，写代码之前一定要把状态转移在dp数组的上具体情况模拟一遍，心中有数，确定最后推出的是想要的结果。

509. 斐波那契数

法一：递归

//时间复杂度：O(2^n)
//空间复杂度：O(n)，递归的系统栈所占空间
class Solution {
public:
    int fib(int n) {
       if(n<=1){
           return n;
       }
       return fib(n-1)+fib(n-2);
    }
};

法二：动规

  1. 确定dp数组（dp table）以及下标的含义

dp[i]:第i个数的斐波那契数值是dp[i]

  1. 确定递推公式

dp[i]=dp[i-1]+dp[i-2]

  1. dp数组如何初始化

dp[0]=0,dp[1]=1,dp[2]=1

  1. 确定遍历顺序

从前往后

  1. 举例推导dp数组

n: 0 1 2 3 4 5 6
dp[n]:0 1 1 2 3 5 8

//时间复杂度：O(n)
//空间复杂度：O(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];
    }
};

空间优化

只需要维护两个数值就可以了，不需要记录整个序列。

class Solution {
public:
    int fib(int N) {
        if (N <= 1) return N;
        int dp[2];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= N; i++) {
            int sum = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = sum;
        }
        return dp[1];
    }
};

70. 爬楼梯

法一，递归超时

class Solution {
public:
    int climbStairs(int n) {
        if(n<=3){
            return n;
        }
        return climbStairs(n-1)+climbStairs(n-2);
    }
};

法二：动态规划

  1. 确定dp数组（dp table）以及下标的含义

dp[i]:爬山不n阶楼有dp[i]种方法

  1. 确定递推公式

dp[i]=dp[i-1]+dp[i-2]

  1. dp数组如何初始化

dp[1]=1,dp[2]=2,dp[3]=3

  1. 确定遍历顺序

从前往后

  1. 举例推导dp数组

    n:0 1 2 3 4 5 6
    dp[i]:1 1 2 3 5 8 13

//时间复杂度：O(n)
//空间复杂度：O(n)
class Solution {
public:
    int climbStairs(int n) {
        vector<int>dp(n+1,0);
        if(n<=2) return n;
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<n+1;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
};

空间优化

class Solution {
public:
    int climbStairs(int n) {
        if(n<=2) return n;
        int a=1;
        int b=2;
        for(int i=3;i<n+1;i++){
            int sum=a+b;
            a=b;
            b=sum;
        }
        return b;
    }
};

746. 使用最小花费爬楼梯

  1. 确定dp数组（dp table）以及下标的含义

dp[i]：爬到第i台阶所花费的最小体力为dp[i]

  1. 确定递推公式

可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。
dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。
dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);

  1. dp数组如何初始化

说了 “你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。” 也就是说 到达 第 0 个台阶是不花费的，但从 第0 个台阶 往上跳的话，需要花费 cost[0]。
所以初始化 dp[0] = 0，dp[1] = 0;

  1. 确定遍历顺序

从前到后

  1. 举例推导dp数组
   cost楼顶:      1   100  1   1   1  100  1   1  100  1
       下标: 0    1    2  3   4   5   6   7   8   9   10
      dp[i]: 0    0    1  2   2   3   3   4   4   5   6

//时间复杂度：O(n)
//空间复杂度：O(n)
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size() + 1);
        dp[0] = 0; // 默认第一步都是不花费体力的
        dp[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[cost.size()];
    }
};

空间优化

/ 版本二
class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int dp0 = 0;
        int dp1 = 0;
        for (int i = 2; i <= cost.size(); i++) {
            int dpi = min(dp1 + cost[i - 1], dp0 + cost[i - 2]);
            dp0 = dp1; // 记录一下前两位
            dp1 = dpi;
        }
        return dp1;
    }
};

62. 不同路径

  1. 确定dp数组（dp table）以及下标的含义

dp[i][j]:表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

  1. 确定递推公式

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

  1. dp数组如何初始化
for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;
  1. 确定遍历顺序

从上到下，从左到右

  1. 举例推导dp数组，m=3,n=2
       0   1      
0      1   1    
1      1   2   
2      1   3 

//时间复杂度：O(m × n)
//空间复杂度：O(m × n)
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m; i++) dp[i][0] = 1;
        for (int j = 0; j < n; j++) dp[0][j] = 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];
    }
};

空间优化：滚动数组

//时间复杂度：O(m × n)
//空间复杂度：O(n)
class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<int> dp(n);
        for (int i = 0; i < n; i++) dp[i] = 1;
        for (int j = 1; j < m; j++) {
            for (int i = 1; i < n; i++) {
                dp[i] += dp[i - 1];
            }
        }
        return dp[n - 1];
    }
};

63. 不同路径 II

  1. 确定dp数组（dp table）以及下标的含义

dp[i][j]:从（0，0）出发，到(i, j) 有dp[i][j]条不同的路径。

  1. 确定递推公式
if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i][j]
    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
  1. dp数组如何初始化

注意代码里for循环的终止条件，一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理

vector<vector<int>> dp(m, vector<int>(n, 0));
for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
  1. 确定遍历顺序

从前到后，从左到右

  1. 举例推导dp数组，m=3,n=3
     0 1 2
0   1 1  1
1   1  0 1
2   1  1 2

//时间复杂度：O(n × m)，n、m 分别为obstacleGrid 长度和宽度
//空间复杂度：O(n × m)
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
	    if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) //如果在起点或终点出现了障碍，直接返回0
            return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

空间优化

//时间复杂度：O(n × m)，n、m 分别为obstacleGrid 长度和宽度
//空间复杂度：O(m)
class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if (obstacleGrid[0][0] == 1)
            return 0;
        vector<int> dp(obstacleGrid[0].size());
        for (int j = 0; j < dp.size(); ++j)
            if (obstacleGrid[0][j] == 1)
                dp[j] = 0;
            else if (j == 0)
                dp[j] = 1;
            else
                dp[j] = dp[j-1];

        for (int i = 1; i < obstacleGrid.size(); ++i)
            for (int j = 0; j < dp.size(); ++j){
                if (obstacleGrid[i][j] == 1)
                    dp[j] = 0;
                else if (j != 0)
                    dp[j] = dp[j] + dp[j-1];
            }
        return dp.back();
    }
};

343. 整数拆分

贪心

//时间复杂度：O(n)
//空间复杂度：O(1)
class Solution {
public:
    int integerBreak(int n) {
        if (n == 2) return 1;
        if (n == 3) return 2;
        if (n == 4) return 4;
        int result = 1;
        while (n > 4) {
            result *= 3;
            n -= 3;
        }
        result *= n;
        return result;
    }
};

动态规划

  1. 确定dp数组（dp table）以及下标的含义

dp[i]: 分拆数字i,可以得到的最大乘积是dp[i]

  1. 确定递推公式

从1遍历j，然后有两种渠道得到dp[i].
一个是j * (i - j) 直接相乘。
一个是j * dp[i - j]，相当于是拆分(i - j)，对这个拆分不理解的话，可以回想dp数组的定义。
递推公式：dp[i] = max({dp[i], (i - j) * j, dp[i - j] * j});

  1. dp数组如何初始化

dp[0]=0,dp[1]=1,dp[2]=1

  1. 确定遍历顺序

dp[i] 是依靠 dp[i - j]的状态，所以遍历i一定是从前向后遍历，先有dp[i - j]再有dp[i]。

for (int i = 3; i <= n ; i++) {
    for (int j = 1; j < i - 1; j++) {
        dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
    }
}
  1. 举例推导dp数组,n=10
    i:2 3  4 5 6 7   8   9   10
dp[i]:1 2  4 6 9 12  18  27  36

//时间复杂度：O(n^2)
//空间复杂度：O(n)
class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1);
        dp[2] = 1;
        for (int i = 3; i <= n ; i++) {
            for (int j = 1; j <= i / 2; j++) {
                dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
            }
        }
        return dp[n];
    }
};

96.不同的二叉搜索树

image.png
dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量
元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量
元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量
元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量
有2个元素的搜索树数量就是dp[2]。
有1个元素的搜索树数量就是dp[1]。
有0个元素的搜索树数量就是dp[0]。
所以dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

  1. 确定dp数组（dp table）以及下标的含义

dp[i]:1到i为节点组成的二叉搜索树的个数为dp[i]。

  1. 确定递推公式

dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]
递推公式:dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量

  1. dp数组如何初始化

dp[0]=0

  1. 确定遍历顺序
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= i; j++) {
        dp[i] += dp[j - 1] * dp[i - j];
    }
}
  1. 举例推导dp数组

下标i:0 1 2 3
dp[i]:1 1 2 5

//时间复杂度：O(n^2)
//空间复杂度：O(n)
class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }
};
Wind哥
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
代码随想录-力扣刷题-总结笔记02
upward
04-04 914
代码随想录-力扣刷题-总结笔记02
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录》中，可能会涵盖如斐波那契数列、背包问题、最长公共子序列等经典动态规划题目。理解动态规划的关键在于构建状态转移方程和找到正确的状态定义。 回溯（Backtracking）是一种试探性的解决问题方法，...
leecode刷题笔记--代码随想录--动态规划--子序列
xixixixixiyu的博客
11-19 128
这部分题建立dp数组时，dp[i]表明的是使用第i个数值时候的情况。
动态规划01背包问题-代码随想录-刷题笔记
Coderwind的博客
06-03 326
动态规划01背包问题-代码随想录-刷题笔记
代码随想录-力扣刷题笔记
m0_49651195的博客
03-12 2042
数组是存放在连续内存空间上的相同数据类型的集合。要查找数组里的数据一般通过查找数据的下标索引的方式来查找。由于数组的这个特性，所以数组删除或添加元素的时候，不能直接进行删除操作。在增加或删除元素的时候，需要通过移动其他元素的地址来达到目的。给定一个n个元素有序的（升序）整型数组nums和一个目标值target，写一个函数搜索nums中的target，如果目标值存在返回下标，否则返回-1。输入：nums = [-1,0,3,5,9,12]输出：4解释：9 出现在nums中并且下标为4。
二叉树的属性-代码随想录-刷题笔记
Coderwind的博客
04-13 454
二叉树的属性-代码随想录-刷题笔记
代码随想录刷题笔记-字符串篇
酸菜鱼翻身历程
06-10 413
每计数2k个，不就是for 循环的时候，索引从 ++变成了 + 2 * k。但是题目有一个小坑，可能数组剩余的元素不足k，这个时候end就是数组的长度。当成easy题的话，就是获取只有一个空格的的数组，然后反转数组再拼接即可。实际开发要是有类似建议这样，如果没有极端场景，性能没那么夸张。前指针指向0，后指针指向s.length() - 1。然后从遍历的start到 k位置反转即可。原地，额外o1的空间，已经明示双指针了。abcd空格 空格 空格 efg 空格。abcd 空格 efg。
回溯算法-代码随想录-组合问题-刷题笔记
Coderwind的博客
05-09 351
回溯算法-代码随想录-组合问题-刷题笔记
代码随想录刷题笔记-数组篇
酸菜鱼翻身历程
06-08 448
进行状态：当快慢指针指向的值不一致时，慢指针先加1，然后再赋值这个加一以后的位置的值。快指针 为1，如果表示下标则指向2 ，满足不等于目标值，先给慢指针的当前值（0）对应的num[0] 赋值2，然后慢指针向后移动，慢指针变成1。快指针 为2，如果表示下标则指向2 ，满足不等于目标值，先给慢指针的当前值（1）对应的num[1] 赋值2，然后慢指针向后移动，慢指针变成2。慢指针是0，指向1，值不一样，慢指针先+1，变成1，然后1这个位置的值赋值2。快指针 为0，如果表示下标则指向3 ，慢指针不动，值还是0。
代码随想录刷题笔记
Twoton的博客
07-12 600
代码随想录对应题目链接 数组是有序数组，是使用二分查找的基础条件。 以后大家只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。或者说可以转换在一个有序数组中找一个数的题目。 同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的。代码随想录对应题目链接 双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。 对于使用双指针的题目，需要明确双指针的含义，针对其含义去思考题解方式。 双指针法（快慢指针法）在数组和链
代码随想录+刷题笔记记录
03-22
本文主要介绍代码随想录的刷题笔记记录，方便读者更好地利用该网站进行学习。 ## 刷题笔记记录的作用 刷题笔记记录是代码随想录提供的一个功能，用于记录用户在刷题过程中的解题思路和方法。它可以帮助用户更好地...
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录-大厂八股文-面试
04-25
代码随想录的大厂八股文面试相关知识点非常广泛，包括了编程基础、算法设计、代码组织、问题解决等多方面的知识点。为了通过面试，考察者需要具备扎实的编程基础和实践经验，能够熟练掌握多种编程语言和技术，能够写...
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
C++笔记5•内存管理•
qq_64446190的博客
08-12 653
内存管理
第二十五天培训笔记
weixin_70756988的博客
08-12 155
选项表示将所有的依赖和代码打包到一个单独的文件中，这样生成的可执行文件更便于。、设置清华镜像站（从国内下载安装包，提高下载和安装工具速度）文件夹中找到生成的可执行文件。可以将这个可执行文件拷贝。在不替换原有代码的情况下，应对数据库软件的升级）到其他机器上（即使该机器没有安装 Python。数据框架，用于保存从数据库中读取的数据）的工具，通过这个工具，就可以。上面命令执行失败：执行该命令。完成打包后，会在当前目录的。）修改为清华大学的镜像源。有完整的读取数据的工具，是知名的数据分析工具，
机器学习笔记：注意力机制中多头注意力的实现
最新发布
2301_79335566的博客
08-12 311
单个注意力学到的东西有限，可以通过对不同的注意力进行组合，学到不同的知识，以达到想要的目的。因此采用”多头注意力“的方法进行实现，即有多个注意力”头“，对其进行连结得到输出。
Linux源码阅读笔记20-PCI设备驱动详解
Lenn Louis' Scribe
08-08 367
【代码】Linux源码阅读笔记20-PCI设备驱动详解。
牛客上代码随想录怎么看题刷题
04-12
牛客网上的代码随想录是一个非常好的刷题平台，它提供了大量的编程题目和解题思路。在牛客网上刷题，可以按照以下步骤进行： 1. 注册并登录牛客网账号。 2. 在主页上找到“代码随想录”板块，点击进入。 3. 在代码...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值