【C++刷题】【动态规划篇】（一）

最新推荐文章于 2024-08-17 23:59:05 发布
最新推荐文章于 2024-08-17 23:59:05 发布
阅读量1.3k 收藏 6
点赞数 5
分类专栏： 刷题杂篇 文章标签： 动态规划 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56177713/article/details/130994507
版权

动态规划篇（一）

一、1137. 第 N 个泰波那契数（easy）

1. 题目链接:1137.第N个泰波那契数

2. 题目描述：

泰波那契序列 Tn 定义如下：
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

3. C++算法代码：

class Solution {
public:
    int tribonacci(int n) {
        //1.状态表示 dp[i] 表⽰：第i个泰波那契数的值。
        //2.状态转移方程 dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]
        //3.初始化 dp[0] = 0,dp[1] = dp[2] = 1
        //4.填表顺序  左->右
        //5.返回值 dp[n]
        
		//未优化版本，时间空间均是O（n）
        if(n==0) return 0;
        if(n==1||n==2) return 1;
        vector<int>dp(n+1);
        dp[0]=0,dp[1]=dp[2]=1;
        for(int i=3;i<=n;++i)
        {
            dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
        }
        return dp[n];
    }

};

滚动数组优化后的C++代码：

class Solution {
public:
    int tribonacci(int n) {
        //1.状态表示 dp[i]表示：第i个泰波那契数的值。
        //2.状态转移方程 dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]
        //3.初始化 dp[0] = 0,dp[1] = dp[2] = 1
        //4.填表顺序  左->右
        //5.返回值 dp[n]
       
		//空间复杂度优化为O（1）
        if(n==0) return 0;
        if(n==1||n==2) return 1;
        
        int a,b,c,d;
        a=0,b=c=1;
        for(int i=3;i<=n;++i)
        {
            d=a+b+c;
            a=b,b=c,c=d;
        }
        return d;

    }

};

二、三步问题（easy）

1. 题目链接：面试题 08.01. 三步问题

2. 题目描述：

三步问题。有个小孩正在上楼梯，楼梯有n阶台阶，小孩一次可以上1阶、2阶或3阶。实现一种方法，计算小孩有多少种上楼梯的方式。结果可能很大，你需要对结果模1000000007。

3. C++算法代码：

class Solution {
public:
    const int A=1e9+7;

    int waysToStep(int n) {
        //1. dp[i] 表⽰：到达i位置时，⼀共有多少种⽅法
        //2.  dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3] 
        //3. dp[1] = 1, dp[2] = 2, dp[3] = 4 
        //4. 左->右
        //5. dp[n]
        if(n==1) return 1;
        if(n==2) return 2;
        if(n==3) return 4;
        vector<int>dp(n+1);
        dp[1]=1,dp[2]=2,dp[3]=4;
        for(int i=4;i<=n;++i)
        {
            dp[i]=((dp[i-1]+dp[i-2])%A+dp[i-3])%A;
        }
        return dp[n];

    }
};

三、使用最小花费爬楼梯（easy）

1. 题目链接：746.使⽤最⼩花费爬楼梯

2. 题目描述：

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

3. C++算法代码：

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        //1. dp【i】 表示走到i层阶梯需要花费的钱
        //2. 动态规划：dp[i]=min(dp[i+1]+cost[i],dp[i+2]+cost[i])
        
        //正向算
        // int n=cost.size();
        // vector<int>dp(n+1);
        // // dp[0]=dp[1]=0;
        // for(int i=2;i<=n;++i)
        // {
        //     dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        // }
        // return dp[n];

        //逆向算
        int n=cost.size();
        vector<int>dp(n);
        dp[n-1]=cost[n-1],dp[n-2]=cost[n-2];
        for(int i=n-3;i>=0;--i)
        {
            dp[i]=min(dp[i+1]+cost[i],dp[i+2]+cost[i]);
        }
        return min(dp[0],dp[1]);
    }
};

四、解码方法（medium）

1. 题目链接：91.解码方法

2. 题目描述：

一条包含字母 A-Z 的消息通过以下映射进行了 编码 ：

‘A’ -> “1”
‘B’ -> “2”
…
‘Z’ -> “26”
要 解码 已编码的消息，所有数字必须基于上述映射的方法，反向映射回字母（可能有多种方法）。例如，“11106” 可以映射为：

“AAJF” ，将消息分组为 (1 1 10 6) “KJF” ，将消息分组为 (11 10 6) 注意，消息不能分组为 (1 11
06) ，因为 “06” 不能映射为 “F” ，这是由于 “6” 和 “06” 在映射中并不等价。

给你一个只含数字的 非空 字符串 s ，请计算并返回 解码 方法的 总数 。

题目数据保证答案肯定是一个 32 位 的整数。

3. C++算法代码：

class Solution {
public:
    int numDecodings(string s) {
	//dp[i] 表⽰：字符串中[0，i]区间上，⼀共有多少种编码⽅法
	//当s[i]上的数在[1, 9]区间上时  dp[i] += dp[i - 1]
	//当s[i - 1]与s[i]上的数结合后，在[10, 26] 之间的时候：
	//dp[i] +=dp[i - 2] 
	
        //不带辅助数组

    //    int n=s.size();
    //    vector<int>dp(n);
    //    dp[0]=s[0]!='0';
    //    if(n==1)return dp[0];
    //    if(s[0]!='0'&&s[1]!='0') dp[1]+=1;
    //    int t=(s[0]-'0')*10+s[1]-'0';
    //    if(t>=10&&t<=26) dp[1]+=1;
    //    for(int i=2;i<n;++i)
    //    {
    //        if(s[i]!='0') dp[i]=dp[i-1];
    //        int t=(s[i-1]-'0')*10+s[i]-'0';
    //        if(t>=10&&t<=26) dp[i]+=dp[i-2]; 
    //    }
    //    return dp[n-1];

        //带辅助数组

        int n=s.size();
        vector<int>dp(n+1);
        dp[0]=1;
        if(s[0]!='0') dp[1]+=1;
        for(int i=2;i<=n;++i)
        {
            if(s[i-1]-'0') dp[i]+=dp[i-1];
            int t=(s[i-2]-'0')*10+s[i-1]-'0';
            if(t>=10&&t<=26) dp[i]+=dp[i-2];
        }
        return dp[n];
    }
};

五、不同路径（medium）

1. 题目链接：62. 不同路径

2. 题目描述：

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

在这里插入图片描述

3. C++算法代码：

class Solution {
public:
    int uniquePaths(int m, int n) {
        //dp[i][j]表⽰：⾛到[i, j] 位置处，⼀共有多少种⽅式。
        // dp[i][j]=dp[i-1][j]+dp[i][j-1];

        vector<vector<int>>dp(m,vector<int>(n,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];
    }
};

六、不同路径II（medium）

1. 题目链接：63. 不同路径 II

2. 题目描述：

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。

在这里插入图片描述

3. C++算法代码：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        //dp[i][j] 表⽰：⾛到 [i, j] 位置处，⼀共有多少种⽅式。
        //不遇到障碍物 dp[i][j]=dp[i][j-1]+dp[i-1][j];
        //遇到障碍物之间变为dp[i][j]=0
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<int>>dp(m+1,vector<int>(n+1));
        dp[0][1]=1;
        for(int i=1;i<=m;++i)
        {
            for(int j=1;j<=n;++j)
            {
                if(obstacleGrid[i-1][j-1]==0)
                {
                   dp[i][j]=dp[i][j-1]+dp[i-1][j];
                }
            }
        }
        return dp[m][n];
    }
};

七、礼物的最大价值（medium）

1. 题目链接：剑指 Offer 47. 礼物的最大价值

2. 题目描述：

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

3. C++算法代码：

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {
        //dp[i][j] 表⽰：⾛到 [i, j] 位置处，此时的最⼤价值
        // dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i-1][j-1];
        
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>>dp(m+1,vector<int>(n+1));
        for(int i=1;i<=m;++i)
        {
            for(int j=1;j<=n;++j)
            {
                dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i-1][j-1];
            }
        }
        return dp[m][n];
    }
};

八、下降路径最小和（hard）

1. 题目链接：931. 下降路径最小和

2. 题目描述：

给你一个 n x n 的 方形 整数数组 matrix ，请你找出并返回通过 matrix 的下降路径 的 最小和 。
下降路径 可以从第一行中的任何元素开始，并从每一行中选择一个元素。在下一行选择的元素和当前行所选元素最多相隔一列（即位于正下方或者沿对角线向左或者向右的第一个元素）。具体来说，位置 (row, col) 的下一个元素应当是 (row + 1, col - 1)、(row + 1, col) 或者 (row + 1, col + 1) 。

在这里插入图片描述

3. C++算法代码：

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& matrix) {
        //dp[i][j] 表⽰：到达[i, j] 位置时，所有下降路径中的最⼩和
        // dp[i][j] = min(dp[i - 1][j], min(dp[i - 1][j - 1], dp[i - 1][j +1])) + matrix[i][j]
        //最⼩值

        int n=matrix.size();

        vector<vector<int>>dp(n+1,vector<int>(n+2,INT_MAX));    //多加一行多加两列
        for(int i=0;i<n+2;++i)
        {
            dp[0][i]=0; //第一行初始化为0
        }

        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=n;++j)
            {
                dp[i][j]=min(dp[i-1][j-1],min(dp[i-1][j],dp[i-1][j+1]))+matrix[i-1][j-1];
            }
        }
        int ret=INT_MAX;
        for(int i=0;i<=n;++i)
        {
            ret=min(ret,dp[n][i]);
        }
        return ret;
    }
};

九、最小路径和

1. 题目链接：64. 最小路径和

2. 题目描述：

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

在这里插入图片描述

3. C++算法代码：

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        //dp[i][j] 表⽰：到达 [i, j] 位置处，最⼩路径和是多少
        //dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
        
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>>dp(m+1,vector<int>(n+1,INT_MAX));
        dp[0][1]=dp[1][0]=0;
        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-1][j-1];
            }
        }
        return dp[m][n];
    }
};

十、地下城游戏

1. 题目链接：174. 地下城游戏

2. 题目描述：

恶魔们抓住了公主并将她关在了地下城 dungeon 的 右下角 。地下城是由 m x n 个房间组成的二维网格。我们英勇的骑士最初被安置在 左上角 的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。
骑士的初始健康点数为一个正整数。如果他的健康点数在某一时刻降至 0 或以下，他会立即死亡。
有些房间由恶魔守卫，因此骑士在进入这些房间时会失去健康点数（若房间里的值为负整数，则表示骑士将损失健康点数）；其他房间要么是空的（房间里的值为 0），要么包含增加骑士健康点数的魔法球（若房间里的值为正整数，则表示骑士将增加健康点数）。
为了尽快解救公主，骑士决定每次只 向右 或 向下 移动一步。
返回确保骑士能够拯救到公主所需的最低初始健康点数。
注意：任何房间都可能对骑士的健康点数造成威胁，也可能增加骑士的健康点数，包括骑士进入的左上角房间以及公主被监禁的右下角房间。

在这里插入图片描述

3. C++算法代码：

class Solution {
public:
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        //本题较为特殊  反向考虑
        //dp[i][j] 表⽰：从 [i, j] 位置出发，到达终点时所需的最低初始健康点数
        //状态转移方程
        //dp[i][j]=min(dp[i+1][j],dp[i][j+1])-dungeon[i][j];
        //同时需要考虑dp[i][j]不能小于0,如果得到的dp[i][j]=min(dp[i+1][j],dp[i][j+1])-dungeon[i][j];
        //其中dungeon[i][j]很大,是一个很大的血包，如果一个负血量的人仍能从这走到终点
        //不符合实际情况，最差要有一滴血
        //所以dp[i][j]=max(1,dp[i][j]); 把负数该为1

        int m=dungeon.size();
        int n=dungeon[0].size();

        vector<vector<int>>dp(m+1,vector<int>(n+1,INT_MAX));
        dp[m][n-1]=dp[m-1][n]=1;
        for(int i=m-1;i>=0;i--)
        {
            for(int j=n-1;j>=0;j--)
            {
                dp[i][j]=min(dp[i+1][j],dp[i][j+1])-dungeon[i][j];
                dp[i][j]=max(1,dp[i][j]);
            }
        }
        return dp[0][0];
    }
};

总结

到这里就暂时结束了，如果有问题可以私信我。

动态规划做题过程总结
//1.状态表示
//2.状态转移方程
//3.初始化
//4.填表顺序
//5.返回值
动态规划需要多做题，积累经验！！！

翻转的乌龟
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
位操作运算符进行刷题,一篇笔记拿下位运算操作
03-30
位操作运算符是编程中非常基础且强大的工具，尤其在C++和其他低级语言中，它们经常被用来优化性能和解决复杂问题。本篇笔记主要关注位操作中的异或（^）和与（&）运算符，以及如何利用它们解决实际问题。 1. **异或...
leetcode-CPP:力扣刷题C ++篇
03-27
leetcode刷题笔记 从3.20起，太简单的就不记录了 数据结构 1.链表 160.链表相交 ...5.动态规划6.贪心算法7.二叉树 105.从前序和中序遍历建造二叉树 二叉树的深度 一体二叉树 8.斐波那契 跳台阶问题
每日一题——力扣——第 N 个泰波那契数
爱编程的晖哥的博客
01-17 327
题目来源于力扣——1137. 第 N 个泰波那契数 - 力扣（LeetCode） (leetcode-cn.com) 泰波那契序列Tn定义如下： T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2 给你整数 n，请返回第 n 个泰波那契数 Tn 的值。 示例 1： 输入：n = 4 输出：4 解释： T_3 = 0 + 1 + 1 = 2 T_4 = 1 + 1 + 2 = 4 示例 2： 输入：n ...
动态规划——第N个泰波那契数
m0_60867520的博客
05-17 428
泰波那契序列 Tn 定义如下： T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2 给你整数 n，请返回第 n 个泰波那契数 Tn 的值。
Leetcode动态规划篇总结（C++）
weixin_42783170的博客
07-29 1088
动态规划-leetcode-总结-代码随想录
【算法刷题】动态规划算法题型及方法归纳
STAR GAME
02-25 2084
动态规划中每一个状态一定是由上一个出来，根据这个特点，可以在过程中，存储某一条件下的数据，当再次遍历该条件时，直接取该条件对应的数据即可，可以避免重复计算，减少时间。
动态规划刷题篇【Day01】
hello_world_juns的博客
05-08 490
假设原始答案为ar[0],计算ar[0]和ar[0]+ar[1]哪个大，如果后者大，将其值存入数组，否则新数组该位仍为ar[0]。输入一个长度为n的整型数组array，数组中的一个或连续多个整数组成一个子数组，子数组最小长度为1。求所有子数组的和的最大值。因为新数组保存的是每次得到的最优解，遍历该数组得到最大的数，就是该问题的解。要求:时间复杂度为 O(n)O(n)，空间复杂度为 O(n)O(n)进阶:时间复杂度为 O(n)O(n)，空间复杂度为 O(1)O(1)选取子问题里面的最优解即和最大。
小白用c++刷题需要知道的基本知识点（一）
weixin_56432571的博客
09-08 730
数据结构与算法作为一个理科在学习中，首先要夯实理论基础，并加以大量刷题。作者以PTA乙级难度为学习目标。这篇文章将从c语言基础的小白视角，从零了解c++基本操作及stl数据库的知识，本人编译器为VS2015，参考书籍为《C Primer Plus》,《清华大学C++语言程序设计第四版》，《啊哈算法》。 第一章 c++简单程序设计 2.1.1 c++程序示例 //2_1.cpp #include <iostream> using namespace std; int main (...
【刷题日记】动态规划经典题目
白晨的博客
02-14 7055
????大家好，我是白晨，一个不是很能熬夜????，但是也想日更的人✈。如果喜欢这篇文章，点个赞????，关注一下????白晨吧！你的支持就是我最大的动力！???????????? 文章目录????前言????动态规划经典题目????1.斐波那契数列????2.拆分词句????3.三角矩阵????4.求路径????5.带权值的最小路径和????6.背包问题????7.分割回文串????8.编辑距离????9.不同子序列????总结 ????前言 观前提醒：这篇文章需要一定动态规划的基础???? ????
刷题中输入处理c++篇
HappyHeavyRain的博客
06-14 1942
刷题中输入处理c++篇cingetlinegetline(cin,s)简单输入输入两行--第一行为n，第二行为n个数字输入多行输入多行--每行不定输入含有空格的字符--getline利用输入流 感觉每次公司做题都会在输入处理中花费太多的时间，有时候甚至写不出来，现在好好总结一下，主要用c++的cin来处 cin cin是C++编程语言中的标准输入流对象,也就是要进行I/O操作，所以的I/O操作均是内核态管理的，操作系统对应所以的标准I/O均有缓冲区的概念，数据先存在缓冲区中，后面再通过系统调用传入用户空间，
C++ 算法篇 动态规划----背包之一 01背包
流年的博客
12-21 6403
一、01背包 题目：有 N 件物品和一个容量为 V 的背包。第 i 件物品的费用是 w[i]，价值是 p[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 例，有3个物品，背包容量为10，如下： 二维解法： #include<bits/stdc++.h> using namespace std; int f[50][220]={...
程序员考试刷题-unprettysoup:UnprettySoup是一个C++库，用于从HTML文件中提取数据
07-07
程序员考试刷题丑汤 Unpretty Soup 是一个 C++ 库，用于从 HTML 文件中提取数据。 它单独使用自己的 Unicode (UTF-8) 解决方案和自己的解析器，以提供简单的导航、搜索、 和修改解析的 DOM 树。 它通常可以为 CS ...
力扣刷题总结c++ 解题报告（持续更新中）（csdn）————程序.pdf
12-05
这些题目展示了C++在解决算法问题时的灵活性和效率，涉及了数据结构（如数组、链表、哈希表、栈和队列）、基本操作（如字符串处理、整数转换、位运算）以及多种算法思想（如暴力求解、动态规划、双指针、滑动窗口、...
信息学奥赛一本通C++——算法和数据结构部分的题目和测试数据
05-07
4. **动态规划**：解决最优化问题的利器，如背包问题、最长公共子序列、矩阵链乘法等，理解和熟练运用动态规划是提高解题能力的关键。 5. **回溯法**：用于求解多解问题，如八皇后问题、N皇后问题、数独等，回溯法...
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 275
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++(11)类语法分析(2)
最新发布
Once_day的回忆
08-17 724
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 879
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 293
C++ | Leetcode C++题解之第337题打家劫舍III
动态规划解题策略与C++刷题心得
这篇文档是关于C++算法的学习笔记，特别关注动态规划这一重要算法主题，旨在帮助读者提高算法能力，为进入大型科技公司（大厂）做准备。作者强调了刷题的重要性，认为数量不是关键，关键是每次解题后的反思和总结。 ...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

翻转的乌龟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值