【数据结构与算法-动态规划系列经典例题汇总】

最新推荐文章于 2024-06-30 21:18:02 发布
最新推荐文章于 2024-06-30 21:18:02 发布
阅读量9.9k 收藏 97
点赞数 8
分类专栏： 数据结构与算法学习 文章标签： 动态规划 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kefenggewu_/article/details/123540776
版权

【数据结构与算法-动态规划系列经典例题汇总】

动态规划概述：

  • 动态规划（dynamic programming）是运筹学的一个分支，是求解决策过程最优化的数学方法。它是最优化原理，利用各阶段之间的关系，逐个求解，最终求得全局最优解。在设计动态规划算法时，需要确认原问题与子问题、动态规划状态、边界状态结值、状态转移方程等关键要素。

典例1、爬楼梯（easy）

  • 题目描述：
    在这里插入图片描述

  • 思路：

  • 暴力解法—回溯—>超时
    在这里插入图片描述

  • 改进：
    在这里插入图片描述

  • 算法流程：

在这里插入图片描述

class Solution {
public:
    int climbStairs(int n) {
        std::vector<int>  dp(n+3,0); // 防止数组越界，传入0？； 【dp】为 dynamic programming 简写
        dp[1] = 1; // 边界值
        dp[2] = 2;
        for(int i=3;i<=n;i++){ 
            dp[i] = dp[i-1] + dp[i-2]; //  动态转移方程（原问题与子问题的关系）
        }
        return dp[n];
    }
};
// int main(){
//     Solution solve;
//     printf("%d\n",solve.climbStairs(3));
//     return 0;
// }

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = [0] * (n + 1) # f(n) = f(n-1) + f(n-2),最后一次递归调用为 f(2) = f(1) + f(0)，边界就是 f(1) = 1，f(0) = 1。
        dp[0]=1 
        dp[1]=1
        for i in range(2,n+1):
            dp[i]=dp[i-1]+dp[i-2]
        return dp[n]
  • 动态规划原理小结：

在这里插入图片描述

典例2、打劫（medium）

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0){return 0;} // 特殊情况
        if(nums.size()==1){return nums[0];}
        int n = nums.size(); 
        vector<int> dp(n,0); //  声明变量存储对应的最优解数值,假定房间i的最优解为dp[i]
        dp[0] = nums[0];  // 边界状态
        dp[1] = max(nums[0],nums[1]);// 边界状态
        for(int i = 2; i< n ; i++){
            dp[i] = max(dp[i-1],dp[i-2]+nums[i]); // 状态转移方程
        }
        return dp[n-1];
    }
};
// int  main(){
//     Solution solve; // 初始化类
//     vector<int> nums;  // 初始化传入的数组
//     nums.push_back(5);
//     nums.push_back(2);
//     nums.push_back(6);
//     nums.push_back(3);
//     nums.push_back(1);
//     nums.push_back(7);
//     printf("%d\n",solve.rob(nums));  // 调用函数，打印结果
//     return 0;
// }

// 结果  ：18

python3

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n==0: return 0
        if n==1: return nums[0]
        dp = [0] * n  # 设第 i 个房间的最优解 为 dp[i]
        dp[0] = nums[0]  # 边界值
        dp[1] = max(nums[0],nums[1])  # 边界值
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-1],dp[i-2]+nums[i])  # 动态转移方程，本质上是相邻的两个房间不能同取 （取i 不取 i）
        return dp[n-1]

典例3、最大字段和（easy）

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n,0); // 初始化数组，存储对应位置的最大值，先以 0 填充
        dp[0] = nums[0];  // 边界状态
        int max_res = dp[0]; // 初始化最大值
        for(int i=1; i< n; i++){
            dp[i] = max(dp[i-1]+nums[i],nums[i]); // 状态转移 （求第i个位置的连续最大值，本质上看之前的 i-1 个是正是负，正就带上，负就舍弃（拖累第i个的大小））
            if(max_res < dp[i]){ // 如果之前的最大结果受到第 i 个数值存在的影响，则更新结果
                max_res = dp[i];
            }
        }
        return max_res; 
    }
};

// int  main(){
//     Solution solve; // 初始化类
//     vector<int> nums;  // 初始化传入的数组
//     nums.push_back(-2);
//     nums.push_back(1);
//     nums.push_back(-3);
//     nums.push_back(4);
//     nums.push_back(-1);
//     nums.push_back(2);
//     nums.push_back(1);
//     nums.push_back(-5);
//     nums.push_back(4);
// printf("%d\n",solve.maxSubArray(nums));  // 调用函数，打印结果
//     return 0;
// }

// 结果  ：6

python 3

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [0] * n  # 初始化数组，存储对应位置的最大值，先以 0 填充
        dp[0] = nums[0] # 边界状态
        max_res = dp[0] # 初始化最大值
        for i in range(1,n):
            dp[i] = max(dp[i-1]+nums[i],nums[i]) # 状态转移 （求第i个位置的连续最大值，本质上看之前的 i-1 个是正是负，正就带上，负就舍弃（拖累第i个的大小））
            if max_res < dp[i]:  #如果之前的最大结果受到第 i 个数值存在的影响，则更新结果
                max_res = dp[i]
        return max_res

典例4、找零钱（medium）

cpp

// #include <stdio.h>

// #include <vector>

class Solution {
public:
    int coinChange(std::vector<int>& coins, int amount) {
		std::vector<int> dp; // 初始化dp数组
		for (int i = 0; i <= amount; i++){
			dp.push_back(-1); // 开始用-1填充
		}
		dp[0] = 0; // 金额 0  最优解 0
		for (int i = 1; i <= amount; i++){  // 循环各个面值，找到dp[i]的最优解
			for (int j = 0; j < coins.size(); j++){   // 递推条件
				if (i - coins[j] >= 0 && dp[i - coins[j]] != -1){ 
					if (dp[i] == -1 || dp[i] > dp[i - coins[j]] + 1){
						dp[i] = dp[i - coins[j]] + 1;   // 递推公式
					}
				}
			}
		}
		return dp[amount];
    }
};

// int main(){	
// 	Solution solve;
// 	std::vector<int> coins;
// 	coins.push_back(1);
// 	coins.push_back(2);
// 	coins.push_back(5);
// 	coins.push_back(7);
// 	coins.push_back(10);	
// 	for (int i = 1; i<= 14; i++){
// 		printf("dp[%d] = %d\n", i, solve.coinChange(coins, i));
// 	}
// 	return 0;
// }

python3

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        dp = [0] + [10001] * (amount)  # 初始化dp数组：因为钱币的数量一定不会超过amount；dp[j]代表含义：拼凑为j的钱数最少需要多少硬币       
        dp[0] = 0
        for coin in coins:  # 遍历所有的单面额钱数（对应的钱数只需1张）
            for j in range(coin, amount + 1): # 从大于面额钱开始
                dp[j] = min(dp[j], dp[j-coin] + 1) # 转移方程 ；当前填满容量j最少需要的硬币 = min( 之前填满容量j最少需要的硬币, 填满容量 j - coin 需要的硬币 + 1个当前硬币）
        # return  dp[amount] if dp[amount] != 10001  else -1  (三次运算符，等价于下面)        
        if  dp[amount] != 10001:
            return dp[amount]
        else:
            return -1  # 如果dp[amount]的值为10001没有变过，说明找不到硬币组合，返回-1
  • python 中：
  • float(“INF”) 表示为正无穷；
  • float("-INF") 表示负无穷
  • 所有数都比 -inf 大，所有数都比 +inf 小就可以了。

典例5、三角形（medium）

  • 题目描述：
    在这里插入图片描述
  • 思路：

在这里插入图片描述
在这里插入图片描述

// #include <stdio.h>

// #include <vector>

class Solution {
public:
    int minimumTotal(std::vector<std::vector<int> >& triangle){
    	if (triangle.size() == 0){
	    	return 0;
	    }
    	std::vector<std::vector<int> > dp;
    	for (int i = 0; i < triangle.size(); i++){
	    	dp.push_back(std::vector<int>());
	    	for (int j = 0; j < triangle.size(); j++){
	    		dp[i].push_back(0);
	    	}
	    }
	    for (int i = 0; i < dp.size(); i++){
    		dp[dp.size()-1][i] = triangle[dp.size()-1][i];
    	}
	    for (int i = dp.size() - 2; i >= 0; i--){
	    	for (int j = 0; j < dp[i].size(); j++)
	    		dp[i][j] = std::min(dp[i+1][j], dp[i+1][j+1])+ triangle[i][j];
    	}
	    return dp[0][0];
    }
};

// int main(){
// 	std::vector<std::vector<int> > triangle;
// 	int test[][10] = {{2}, {3, 4}, {6, 5, 7}, {4, 1, 8, 3}};
// 	for (int i = 0; i < 4; i++){
// 		triangle.push_back(std::vector<int>());
// 		for (int j = 0; j < i + 1; j++){
// 			triangle[i].push_back(test[i][j]);
// 		}
// 	}
// 	Solution solve;
// 	printf("%d\n", solve.minimumTotal(triangle));
// 	return 0;
// }

python3

典例6、最长上升子序列（medium）


// #include <stdio.h>

// #include <vector>

class Solution {
public:
    int lengthOfLIS(std::vector<int>& nums) {
    	if (nums.size() == 0){
	    	return 0;
	    }
        std::vector<int> dp(nums.size(), 0);
        dp[0] = 1;
        int LIS = 1;
        for (int i = 1; i < dp.size(); i++){
        	dp[i] = 1;
        	for (int j = 0; j < i; j++){
	        	if (nums[i] > nums[j] && dp[i] < dp[j] + 1){
	        		dp[i] = dp[j] + 1;
	        	}
	        }
	        if (LIS < dp[i]){
        		LIS = dp[i];
        	}
        }
        return LIS;
    }
};

// int main(){
// 	int test[] = {10, 9, 2, 5, 3, 7, 101, 18};
// 	std::vector<int> nums;
// 	for (int i = 0; i < 8; i++){
// 		nums.push_back(test[i]);
// 	}
// 	Solution solve;
// 	printf("%d\n", solve.lengthOfLIS(nums));
// 	return 0;
// }

python3

典例7、最小路径和（medium）


// #include <stdio.h>

// #include <vector>

class Solution {
public:
    int minPathSum(std::vector<std::vector<int> >& grid) {
    	if (grid.size() == 0){
	    	return 0;
	    }
	    int row = grid.size();
    	int column = grid[0].size();
    	std::vector<std::vector<int> > 
						dp(row, std::vector<int>(column, 0));
    	
	    dp[0][0] = grid[0][0];
	    for (int i = 1; i < column; i++){
    		dp[0][i] = dp[0][i-1] + grid[0][i];
    	}
	    for (int i = 1; i < row; i++){
	    	dp[i][0] = dp[i-1][0] + grid[i][0];
    		for (int j = 1; j < column; j++){
		    	dp[i][j] = std::min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
		    }
    	}
	    return dp[row-1][column-1];
    }
};

// int main(){
// 	int test[][3] = {{1,3,1}, {1,5,1}, {4,2,1}};
// 	std::vector<std::vector<int> > grid;
// 	for (int i = 0; i < 3; i++){
// 		grid.push_back(std::vector<int>());
// 		for (int j = 0; j < 3; j++){
// 			grid[i].push_back(test[i][j]);
// 		}
// 	}
// 	Solution solve;
// 	printf("%d\n", solve.minPathSum(grid));	
// 	return 0;
// }

python3

典例8、地下城游戏（hard）

  • 题目描述：
    在这里插入图片描述

  • 思路：
    在这里插入图片描述

在这里插入图片描述

// class Solution {
// public:
//     int calculateMinimumHP(vector<vector<int>>& dungeon) {

//     }
// };
// #include <stdio.h>

// #include <vector>

class Solution {
public:
    int calculateMinimumHP(std::vector<std::vector<int> >& dungeon) {
    	if (dungeon.size() == 0){
	    	return 0;
	    }
    	std::vector<std::vector<int> > 
			dp(dungeon.size(), std::vector<int>(dungeon[0].size(), 0));
    	int row = dungeon.size();
    	int column = dungeon[0].size();
    	dp[row-1][column-1] = std::max(1, 1-dungeon[row-1][column-1]);
    	for (int i = column-2; i>=0; i--){
	    	dp[row-1][i] = std::max(1,
									dp[row-1][i+1] - dungeon[row-1][i]);
	    }
	    for (int i = row-2; i>=0; i--){
	    	dp[i][column-1] = std::max(1,
								dp[i+1][column-1] - dungeon[i][column-1]);
	    }
	    for (int i = row-2; i>=0; i--){
    		for (int j = column-2; j>=0; j--){
    			int dp_min = std::min(dp[i+1][j], dp[i][j+1]);
		    	dp[i][j] = std::max(1, dp_min - dungeon[i][j]);
		    }
    	}
	    return dp[0][0];
    }
};

// int main(){
// 	int test[][3] = {{-2, -3, 3}, {-5, -10, 1}, {10, 30, -5}};
// 	std::vector<std::vector<int> > dungeon;
// 	for (int i = 0; i < 3; i++){
// 		dungeon.push_back(std::vector<int>());
// 		for (int j = 0; j < 3; j++){
// 			dungeon[i].push_back(test[i][j]);
// 		}
// 	}
// 	Solution solve;
// 	printf("%d\n", solve.calculateMinimumHP(dungeon));
// 	return 0;
// }

python3
Wupke
关注
  • 8
    点赞
  • 踩
  • 97
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《算法和数据结构》数学基础总结
英雄哪里出来
12-27 1万+
算法中的数学基础，你掌握了多少？
动态规划问题经典例题
dddddrrrzz的博客
02-23 7849
DP（Dynamic Programming）定义： 动态规划是分治思想的延伸，通俗一点来说就是大事化小，小事化无的艺术。在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果。 动态规划具备了以下三个特点： 把原来的问题分解成了几个相似的子问题。 所有的子问题都只需要解决一次。 储存子问题的解 动态规划的本质，是对问题状态的定义和状态转移方程的定义(状态以及状态
动态规划算法经典例题
05-16
一些动态规划，最新最典型的算法！如，背包问题，钢管切割问题，最长子序列问题等等。
算法学习笔记：动态规划详解（示例：Go）
最新发布
风不归的乐园
06-30 1099
算法学习笔记：动态规划详解（示例：Go）
动态规划
dianlu7964的博客
06-26 300
终于来到了算法设计思想中最有趣的这部分，在去年的google笔试中，7道算法设计题有2道动态规划（Dynamic Programming）。看了这么久的算法，这部分也是唯一感觉到了比较难的地方，从这篇文章开始，将花连续的篇幅来讨论一些对动态规划的认识和其中的问题。这包括一些例子：计算二项式系数，Warshall算法求传递闭包，Floyd算法求完全最短路径，构造最有二叉查找树，...
动态规划经典例题汇总 （附最全题目链接）
好多鱼
02-18 1万+
本文总结了王道机试指南中动态规划（Dynamic Progamming）部分的所有例题。 一.基本思想 与分治法类似，其基本思想也是将待求解问题分解成若干子问题，先求解子问题，然后从这些子问题的解中得到原问题的解。 与分治法不同的是，分治法会使得有些子问题被重复计算多次。而动态规划的做法是将已解决子问题的答案保存下来，在需要子问题答案的时候便可直接获得，而不需要重复计算，节约效率。 二.经典题目 ...
动态规划算法经典题目
09-15
几道动态规划的经典算法 非常经典 值得分享
动态规划经典例题
weixin_46271002的博客
06-14 837
恰好 和 不超过 切割次数不超过k次和恰好切割k次的区别仅仅在于dp[i][j],j>=i时的定义不同，一个是无效值，一个是有效值（有点像背包要求装满或不要求转满时的最优解） 所以装满和不要求装满，恰好k次和不超过k次的 主要递推式其实是一样的，区别只在于初始化时，对相关变量的赋值不同 如果是恰好切割k次，则对于j>=i，即长度为i的钢管一定切不了大于长度i的j次，所以它是一个无效解，且因为要求价值最大，所以赋值无效值为-inf 如果是切割次数不超过k次，则对于j>=i，即长度为i的钢管
C语言经典例题，小甲鱼C语言例题
03-03
本资源汇总了 C 语言经典例题，小甲鱼 C 语言例题共 19 道题目，涵盖了 C 语言的基本概念、数据类型、运算符、控制结构、函数、数组、指针等方面的知识点。 知识点 1：数组和循环 - 例题 1：有 1、2、3、4 这 4 个...
SDU数据仓库与数据挖掘 重要算法提纲
feilongzzz的博客
06-01 1063
数据仓库与数据挖掘 复习提纲
排列&组合计算公式及经典例题汇总.doc
10-07
在IT行业中，理解这些概念可以帮助解决算法设计、数据结构优化等问题。 1. **排列** (Arrangements, A) 排列指的是从n个不同元素中，任取m个元素按照特定顺序排成一列的方式。排列的关键在于顺序。计算排列数的...
动态规划经典题目
11-23
动态规划经典题目：包括了经典的最长不下降子序列，最长公共子序列，01背包，完全背包，部分背包等算法的详解。
算法与数据结构【30天】集训营——线性表之链式表的表示与实现及顺表与链表比较（04）
迷茫与徘徊只会让你陷入绝境，欢迎私信博主，带你开始提升变现价值！
08-07 719
线性表的链式存储又称单链表， 它是指通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外， 还需要存放一个指向其后继的指针。//定义单链表结点类型 ElemType data;//数据域 struct LNode * next;/ 指针域 } LNode , * LinkList;增加头结点的单链表① 由于第一个数据结点的位置被存放在头结点的指针域中，因此在链表的第一个位置上的操作和在表的其他位置上的操作一致，无须进行特殊处理。...
几个经典的动态规划的算法
热门推荐
jpbj_zb的博客
05-05 1万+
列举几个动态规划经典的算法
动态规划算法经典例题_动态规划的经典模型
weixin_35774446的博客
01-14 975
动态规划算法的核心就是记住已经解决过的子问题的解。记住求解的方式有两种：①自顶向下的备忘录法②自底向上。动态规划的经典模型线性模型线性模型的是动态规划中最常用的模型，上文讲到的钢条切割问题就是经典的线性模型，这里的线性指的是状态的排布是呈线性的。【例题1】是一个经典的面试题，我们将它作为线性模型的敲门砖。【例题1】在一个夜黑风高的晚上，有n（n <= 50）个小朋友在桥的这边，现在他们需要过...
【数据结构与算法】之动态规划经典问题
小新要变强的博客
11-11 5706
本文将对【数据结构与算法】动态规划经典问题相关介绍 ，具体将对最长递增子序列问题，找零钱问题，0-1背包问题相关动态规划算法问题进行详尽介绍~
动态规划及其动态规划经典例题
追梦少年ML的博客
04-04 984
引言： 动态规划是最重要、最经典的算法之一，学好动态规划对我们十分重要，掌握动态规划对解决某些问题会起到事半功倍的效果。 动态规划： 特点： ①可以把原始问题划分为一系列子问题 ②求解每个子问题仅一次，并将其结果保存到一个表中，以后用到时直接存取，不重复计算，节省时间。 ③自底向上地计算 适用范围： 原问题可以分为多个相关子问题，子问题的解会被重复使用。 动态规划题目的特点： 1.计数 -有多少种...
动态规划经典五题
nayao-net
12-02 533
DP一年多没碰过了，今天突然想找找感觉，找了经典的几道DP复习着敲了敲。虽然最大子矩阵，滑雪，石子合并等问题也足够经典，我还是从中找了5道最经典的DP写了这篇博文，如果您是大一，大二想踏入程序竞赛的同学可以当习题做做，如果您像我一样不是ACMer，平时项目中也很少用DP，同样可以回顾一下DP的奥妙。 1.最大连续子序列之和 给定K个整数的序列{ N1, N2, ..., NK }，其任意连...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值