【C++刷题】【动态规划篇】(一)

这篇具有很好参考价值的文章主要介绍了【C++刷题】【动态规划篇】(一)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、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” )。
问总共有多少条不同的路径?

【C++刷题】【动态规划篇】(一)

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 来表示。

【C++刷题】【动态规划篇】(一)

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) 。

【C++刷题】【动态规划篇】(一)

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 ,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。
说明:每次只能向下或者向右移动一步。

【C++刷题】【动态规划篇】(一)

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),要么包含增加骑士健康点数的魔法球(若房间里的值为正整数,则表示骑士将增加健康点数)。
为了尽快解救公主,骑士决定每次只 向右 或 向下 移动一步。
返回确保骑士能够拯救到公主所需的最低初始健康点数。
注意:任何房间都可能对骑士的健康点数造成威胁,也可能增加骑士的健康点数,包括骑士进入的左上角房间以及公主被监禁的右下角房间。

【C++刷题】【动态规划篇】(一)

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.返回值
动态规划需要多做题,积累经验!!!文章来源地址https://www.toymoban.com/news/detail-475261.html

到了这里,关于【C++刷题】【动态规划篇】(一)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【学会动态规划】第 N 个泰波那契数(1)

    目录 动态规划怎么学? 1. 题目解析 2. 算法原理 1. 状态表示 2. 状态转移方程 3. 初始化 4. 填表顺序 5. 返回值 3. 代码编写 4. 空间优化 写在最后 学习一个算法没有捷径,更何况是学习动态规划, 跟我一起刷动态规划算法题,一起学会动态规划! 题目链接:1137. 第 N 个泰波那

    2024年02月15日
    浏览(45)
  • 【学会动态规划】第 N 个泰波那契数(4)

    目录 动态规划怎么学? 1. 题目解析 2. 算法原理 1. 状态表示 2. 状态转移方程 3. 初始化 4. 填表顺序 5. 返回值 3. 代码编写 写在最后: 学习一个算法没有捷径,更何况是学习动态规划, 跟我一起刷动态规划算法题,一起学会动态规划! 这道题目不难理解,就是根据题目给的字

    2024年02月16日
    浏览(37)
  • LeetCode第 N 个泰波那契数 (认识动态规划)

    链接: 第 N 个泰波那契数 编写代码 代码空间优化 一般像这种情况我们可以使用滚动数组的方式来解决空间的问题

    2024年02月15日
    浏览(39)
  • 【动态规划专栏】专题一:斐波那契数列模型--------1.第N个泰波那契数

    本专栏内容为:算法学习专栏,分为优选算法专栏,贪心算法专栏,动态规划专栏以及递归,搜索与回溯算法专栏四部分。 通过本专栏的深入学习,你可以了解并掌握算法。 💓博主csdn个人主页:小小unicorn ⏩专栏分类:动态规划专栏 🚚代码仓库:小小unicorn的代码仓库🚚

    2024年02月21日
    浏览(43)
  • 算法刷题Day 38 动态规划理论基础+斐波那契数+爬楼梯

    动态规划的解题步骤: 确定 dp 数组(dp table)以及下标的含义 确定递推公式 dp 数组如何初始化 确定遍历顺序 举例推导 dp 数组 很基础

    2024年02月15日
    浏览(63)
  • LeetCode刷题笔记【29】:动态规划专题-1(斐波那契数、爬楼梯、使用最小花费爬楼梯)

    动态规划(DP,Dynamic Programming)。 其解题思路对比 贪心算法的“直接选局部最优然后推导出全局最优” ;倾向于“ 由之前的结果推导得到后续的结果 ”。 很多时候二者具有相似性,不必死扣概念。 动态规划题目的核心是dp数组的概念和构建(递推公式); 所以具体的解题步骤

    2024年02月09日
    浏览(40)
  • 力扣第509题 斐波那契数 新手动态规划(推荐参考) c++

    509. 斐波那契数 简单 相关标签 递归   记忆化搜索   数学   动态规划 斐波那契数  (通常用  F(n)  表示)形成的序列称为  斐波那契数列  。该数列由  0  和  1  开始,后面的每一项数字都是前面两项数字的和。也就是: 给定  n  ,请计算  F(n)  。 示例 1: 示例 2:

    2024年02月07日
    浏览(50)
  • 【LeetCode题目详解】第九章 动态规划part01 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯 (day38补)

    斐波那契数  (通常用  F(n) 表示)形成的序列称为 斐波那契数列 。该数列由  0 和 1 开始,后面的每一项数字都是前面两项数字的和。也就是: 给定  n ,请计算 F(n) 。 示例 1: 示例 2: 示例 3: 提示: 0 = n = 30 斐波那契数列大家应该非常熟悉不过了,非常适合作为动规第

    2024年02月07日
    浏览(47)
  • 【动态规划】是泰波那契数,不是斐波那契数

    Problem: 1137. 第 N 个泰波那契数 首先我们来解读一下本题的意思🔍 相信读者在看到【泰波那契数】的时候,不禁会联想到【斐波那契数】,它们呢是一对孪生兄弟,这个 泰波那契数 相当于是 斐波那契数 的加强版 我们首先可以来看到这个递推公式 Tn+3 = Tn + Tn+1 + Tn+2 ,读者可

    2024年02月08日
    浏览(48)
  • 动态规划-斐波那契数

    斐波那契数是一个很好的熟悉和理解动态规划的例子,通过斐波那契数可以更好的理解动态规划的精髓,动态规划是后面的计算是如何借助于前面的计算结果来加快计算速度的。 斐波那契数和斐波那契数列其实可以看成是一道题,只不过两题的限制性条件稍微有差别 斐波那

    2024年02月14日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包