动态规划Dynamic programming

已于 2022-01-20 15:58:44 修改
阅读量65 收藏
点赞数
分类专栏： 动态规划 # 上升、公共子序列 文章标签： 动态规划 c++ 算法
于 2021-10-22 19:29:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51070956/article/details/120792086
版权

凑在一起有新发现了不？

有新发现了不？

最长上升子序列

传送门

#include <bits/stdc++.h>
using namespace std;
//1、分解成子问题 2、无后效性，一种状态A只与另一种状态B的值有关，与状态B的到达方式无关 


int main(int argc, char** argv) {
	int n;
	cin>>n;
	int a[n];
		int dp[n];//存放以a[k]为结尾的序列的最长上升子序列
//	dp[0]=1;
	for(int i=0;i<n;i++){
		cin>>a[i];
		dp[i]=1;
	}

	
	for(int k=1;k<n;k++){
		int m=1;//不能初始化为-1，如果dp[k]前面的数都比他大呢，那么 dp[k]就等于-1了呀 
		for(int i=0;i<k;i++){
			if(a[i]<a[k]){
				dp[k]=dp[i]+1;
				if(dp[k]>m)m=dp[k];
			}
		}
		dp[k]=m;
//	for(int i=0;i<k;i++){
//		if(a[i]<a[k])dp[k]=max(dp[i]+1,dp[k]);
//	}
	}
	cout<<*max_element(dp,dp+n);
//	int m=-1;
//	for(int k=0;k<n;k++){
//		if(dp[k]>m)m=dp[k];
//	}
//	cout<<m;
	return 0;
}

help Jimmy

#include <bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f   //超级适合表示infinite 
struct st{
	int x1,x2,h; 
}a[1001];
//st  a[1001];
bool cmp(st s1,st s2){
	return (s1.h<s2.h);
	//按照板子的高度由低到高 排序编号，地面编号为0，出发处编号为n+1 
}
int dp[1001][2]; //dp[i][0]表示 从第i块板子对应位置 往左而下 到达地面的最短时间
int n,x,y,mx;
void left(int i){//求出 从第i块板子对应位置 往左而下 到达地面的最短时间
	int k=i-1;//i左下角的一块板子、
	while(k>0&&a[i].h-a[k].h<=mx){
	if(a[k].x1<=a[i].x1&&a[k].x2>=a[i].x1) {
		dp[i][0]=a[i].h-a[k].h+min(dp[k][0]+a[i].x1-a[k].x1,dp[k][1]+a[k].x2-a[i].x1);
		return;
	}
	else k--;//再找左下方向下面一块板子 
}
	if(a[i].h-a[k].h>mx)dp[i][0]= inf;
	else if(k==0)dp[i][0]=a[i].h-a[k].h; 
}
void right(int i){//求出 从第i块板子对应位置 往右而下 到达地面的最短时间
	int k=i-1;//i右下角的一块板子、
	while(k>0&&a[i].h-a[k].h<=mx){
	if(a[k].x1<=a[i].x2&&a[k].x2>=a[i].x2) {
		dp[i][1]=a[i].h-a[k].h+min(dp[k][0]+a[i].x2-a[k].x1,dp[k][1]+a[k].x2-a[i].x2);
		return;
	}
	else k--;//再找左下方向下面一块板子 
}
	if(a[i].h-a[k].h>mx)dp[i][1]= inf;
	else if(k==0)dp[i][1]=a[i].h-a[k].h; 
}
int main(int argc, char** argv) {
	int t;
	cin>>t;
	while(t--){
		cin>>n>>x>>y>>mx;
//		int a[n][3];
//		for(int i=0;i<n;i++){
//			for(int j=0;j<3;j++){
//				cin>>a[i][j];
//			}
//		}
//以后要反应过来用结构体噢，三元组的形式，一来仅用a[i][0/1/2]不能很好见名知意
//二来 刚刚思索了一会怎么给这个三元组根据a[i][2]来排序，Cpp运算符重载和sort函数似乎都做不到 
//数据结构似乎讲过，不过当然想不起来
	for(int i=1;i<=n;i++){
		cin>>a[i].x1>>a[i].x2>>a[i].h;
	}
	a[n+1].h=y;
	a[n+1].x1=a[n+1].x2=x;
	a[0].h=0;
	a[0].x1=-20000 ;
	a[0].x2=20000;	
	sort(a,a+n+1,cmp);
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=n+1;i++){
		left(i);
		right(i);
	}	
	cout<<min(dp[n+1][0],dp[n+1][1])<<endl; 
	}
		return 0;
	}

滑雪

#include <bits/stdc++.h>
using namespace std; 
#define MAX 105
int a[MAX][MAX];
int dp[MAX][MAX];
int m,n;
int dx[4]={0,0,-1,1};
int dy[4]={1,-1,0,0};
int dfs(int x,int y){
	if(dp[x][y]>0)return dp[x][y];//如果这个点的最长路径已经算出，直接返回
	dp[x][y]=1;
		for(int k=0;k<4;k++){
			if((x+dx[k])>=0&&(x+dx[k])<=m-1&&(y+dy[k])>=0&&(y+dy[k])<=n-1&&a[x+dx[k]][y+dy[k]]<a[x][y])
			dp[x][y]=max(dp[x][y],dfs(x+dx[k],y+dy[k])+1);
			}
			return dp[x][y];
}
int main(int argc, char** argv) {
	cin>>m>>n;
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			cin>>a[i][j];
			dp[m][n]=-1;
		}
	}	
	int ans=0;
	for(int i=0;i<m;i++){
		for(int j=0;j<n;j++){
			ans=max(ans,dfs(i,j));//从哪个点出发路径最长 
		}
	}
	cout<<ans<<endl;	
		return 0;
	} 


#include<iostream>  
using namespace std;
const int Max = 105;
 
int row, col;
int map[Max][Max];                           //  记录图各点的高度。  
int dp[Max][Max];                            //  记录以各点为起点的最长下降路径的长度。  
 
int dfs(int r, int c)
{
	if (dp[r][c] != 0)
		return dp[r][c];      //  若dp[r][c]不为0，则表示它已被访问。  
	int max = 1;
	if (r + 1 <= row && map[r][c] > map[r + 1][c])
	{
		int len = dfs(r + 1, c) + 1;
		if (len > max)
			max = len;
	}
	if (r - 1 >= 1 && map[r][c] > map[r - 1][c])
	{
		int len = dfs(r - 1, c) + 1;
		if (len > max)
			max = len;
	}
	if (c + 1 <= col && map[r][c] > map[r][c + 1])
	{
		int len = dfs(r, c + 1) + 1;
		if (len > max)
			max = len;
	}
	if (c - 1 >= 1 && map[r][c] > map[r][c - 1])
	{
		int len = dfs(r, c - 1) + 1;
		if (len > max)
			max = len;
	}
	return map[r][c] = max;
}
 
int main()
{
	int i, j;
	cin >> row >> col;
	for (i = 1; i <= row; i++)
	for (j = 1; j <= col; j++)
		cin >> map[i][j];
	int ans = 0;
	memset(dp, 0, sizeof(dp));//给dp[][]全部初始化为0
	for (i = 1; i <= row; i++)
	for (j = 1; j <= col; j++)
	{
		dp[i][j] = dfs(i, j);  //  用记忆化搜索求出dp[i][j]，同时也求出了其路径上的dp[x][y]。  
		if (dp[i][j] > ans)
			ans = dp[i][j];
	}
	cout << ans << endl;
	return 0;
}
//这种做法也差不多，没用dx，dy方向数组罢了
原文链接：https://blog.csdn.net/qq_42020563/article/details/80644017

神奇口袋

#include <bits/stdc++.h>
using namespace std;
int dp[25][45]; //dp[i][j]表示从i件商品选出总质量j的选法 
int main(int argc, char** argv) {
		int n;
		cin>>n;
		int w[n];
		for(int i=0;i<n;i++){
			cin>>w[i];
		}
		memset(dp,0,sizeof(dp));
		for(int j=0;j<=n;j++){
			dp[j][0]=1;//选的质量为0，一种选法：啥也不选 
		}
		for(int i=1;i<=n;i++){//从i件商品中选，选不选第i件商品 对应的是 w[i-1]
			for(int j=1;j<=40;j++){
			if(j-w[i-1]>=0)dp[i][j]=dp[i-1][j]+dp[i-1][j-w[i-1]];
			else dp[i][j]=dp[i-1][j];
			}
		}
		cout<<dp[n][40]<<endl;
		return 0;
	}

7113:Charm Bracelet（典型01口袋）

#include <bits/stdc++.h>
using namespace std; 
#define MAX 34050
int v[MAX];//每件物品的重量 
int w[MAX];//每件物品的价值 
int n,m;
int dp[MAX]; 
int main(int argc, char** argv) {
		cin>>n>>m;//n个物品，拿走至多m重量
		 for(int i=0;i<n;i++){
		 	cin>>w[i]>>v[i];
		 } 
		 memset(dp,0,sizeof(dp));
		 for(int i=1;i<=n;i++){
		 	for(int j=m;j>=1;j--){//递推出dp[i][j]
		 		if(j>=w[i-1])dp[j]=max(dp[j],v[i-1]+dp[j-w[i-1]]);
			 }
		 } 
		 cout<<dp[m];
		return 0;
	}

7215:简单的整数划分问题

#include <bits/stdc++.h>
using namespace std;
#define MAX 51 
int dp[MAX][MAX];//递推思想：dp[i][j]表示整数i以j为最大因子的划分种数 
int main(int argc, char** argv) {
	int x;
	memset(dp,0,sizeof(dp));
		while(cin>>x){
	//	5, 4+1, 3+2, 3+1+1, 2+2+1, 2+1+1+1, 1+1+1+1+1
	//从221，可以看出，以2为最大因子那么划分x-2的因子不能超过2 
	//dp[i][j]=dp[i-j][j]+dp[i][j-1]; i>=0
		dp[0][0]=1;//考虑到分解x，只有下本身这个因子这种分解方式 
		for(int i=0;i<=x;i++){
			for(int j=1;j<=x;j++){
				if(i<j)dp[i][j]=dp[i][j-1]; 
				else dp[i][j]=dp[i-j][j]+dp[i][j-1];
			}
		}
	
		cout<<dp[x][x]<<endl;//x以x为最大因子，划分方式中因子可以不含x，但是一定都小于x 
}
		return 0;
	}

7219:复杂的整数划分问题

#include <bits/stdc++.h>
using namespace std;
#define MAX 51 
typedef long long int ll;
ll dp[MAX][MAX];//dp[i][j]表示把i划分成j个数的划分种数 
ll dp2[MAX][MAX];//dp2[i][j]表示把i划分成若干个不同整数的划分种数 ，以j为最大因子 
ll dp3[MAX][MAX];//dp2[i][j]表示把i划分成
int main(int argc, char** argv) {
	int n,k;
	while(cin>>n>>k){
	memset(dp,0,sizeof(dp));//dp[5][2]
//		for(int i=1;i<=n;i++)dp[i][1]=1;
	for(int i=1;i<=n;i++){
		dp[i][1]=1;
	for(int j=2;j<=n;j++){
		if(i>=j){
//		dp[i][j]+=dp[i-1][j-1];
//		if(i-j>=0)dp[i][j]+=dp[i-j][j];
		dp[i][j]=dp[i-1][j-1]+dp[i-j][j];
		}
}
}
	cout<<dp[n][k]<<endl;	
	memset(dp2,0,sizeof(dp2));//dp[5][2]
		dp2[0][0]=1;//唯独这个特殊，当划分组合中只有最大因子这一个因子 
	for(int i=0;i<=n;i++){
		for(int j=1;j<=n;j++){//至少以1为最大因子咯，以0就是没有分解方式 已经初始化为0啦 
		if(i<j)dp2[i][j]=dp2[i][i]; 
		else{	
		dp2[i][j]=dp2[i-j][j-1]+dp2[i][j-1];//5 5
			}			
		}
	} 
	cout<<dp2[n][n]<<endl;
	
		memset(dp3,0,sizeof(dp3));//dp[5][2]
		dp3[0][0]=1;
//		for(int j=0;j<=n;j++){//这是我没想到的 没想明白 
//			dp3[j][1]=1;
//			if(j%2==1)dp3[0][j]=1;//只由自身一个奇数组成时，i得到0，
至于为何j要为奇数因为 ,得到这个0是由上一个i减去这个j的，i==j必须要是一个奇数 
//		}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){//至少以1为最大因子咯，以0就是没有分解方式 已经初始化为0啦 
			if(j%2==1){
//			if(i>=j)dp3[i][j]=dp3[i-j][j]+dp3[i][j-1];
				if(i>j)dp3[i][j]=dp3[i-j][j]+dp3[i][j-1]; 
				else if(i==j)dp3[i][j]=dp3[i][j-1]+1;
				else dp3[i][j]=dp3[i][i];
			}
//			if(i>=j){//dp3[i][j]=dp3[i-j][j-2]+dp3[i][j-2];//5 5
//		}
			else dp3[i][j]=dp3[i][j-1];
		}
	} 
	cout<<dp3[n][n]<<endl;
//	if(n%2==1)cout<<dp3[n][n]<<endl;
//	else cout<<dp3[n][n-1]<<endl;//其实没有必要，上面一条else语句就会将偶数转化成奇数的 
}
		return 0;
	}
Selvaggia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
运筹学状态转移方程例子_动态规划 Dynamic Programming
weixin_39603823的博客
12-20 815
从运筹学和算法的角度综合介绍动态规划规划论 Mathematical Programming / Mathematical OptimizationIn mathematics, computer science and operations research, mathematical optimization or mathematical programming, alternatively...
动态规划dynamic programming
04-19
动态规划（Dynamic Programming，简称DP）是计算机科学中一种强大的问题解决方法，广泛应用于算法设计与分析中。它主要处理具有重叠子问题和最优子结构的问题，通过将复杂问题分解为更小的子问题来求解全局最优解。...
算法-动态规划 Dynamic Programming--从菜鸟到老鸟
热门推荐
有图有真相
07-15 45万+
前言最近在牛客网上做了几套公司的真题，发现有关动态规划（Dynamic Programming）算法的题目很多。相对于我来说，算法里面遇到的问题里面感觉最难的也就是动态规划（Dynamic Programming）算法了，于是花了好长时间，查找了相关的文献和资料准备彻底的理解动态规划（Dynamic Programming）算法。一是帮助自己总结知识点，二是也能够帮助他人更好的理解这个算法。后面的参
动态规划 Dynamic programming
Jeff_的博客
09-13 1666
文章目录一、前言二、优点三、引申1. [coin-change](https://leetcode.com/problems/coin-change/solution/) 换零钱问题2. [Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum/) 最小路径问题3. [Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum
动态规划Dynamic programming详解-最长公共子序列【python】
10年数据\经营分析经验，现任大厂数据分析负责人
04-16 1372
本文详细介绍了解决最长公共子序列（LCS）问题的动态规划方法。通过定义状态转移方程和初始化条件，我们能有效计算两字符串的LCS长度。此方法具体、高效，适合处理复杂的字符串匹配问题。
动态规划（Dynamic programming）详解（全）
走向CTO的路上...
06-10 708
动态规划（Dynamic Programming）是一种解决复杂问题的算法思想，通过将问题拆分为子问题，并利用子问题的解来构建更大规模问题的解。总之，动态规划是一种重要的算法思想，通过将问题划分为子问题并利用子问题的解来求解更大规模的问题。未来，随着技术的进步和需求的增加，动态规划算法将继续发展和扩展，为解决复杂问题提供更加高效和准确的方法。动态规划是一种强大的算法思想，适用于解决各种复杂问题。通过将问题拆分为子问题，并利用子问题的解来构建更大规模问题的解，动态规划能够有效地提高问题的求解效率和准确性。
算法专题1——动态规划 Dynamic Programming，DP
定期分享我的发现和想法，感谢你的陪伴和支持
09-29 5430
本文主要为，代码随想录的学习笔记。 由dp[j-weight[i]]推导出来的，然后取max(dp[j], dp[j - weight[i]] + value[i])。写代码前将状态转移在dp数组上具体模拟一遍，确认是想要的结果。如果某⼀问题有很多重叠⼦问题，使⽤动态规划。贪心没有状态推导，⽽是从局部直接选最优的。
动态规划Dynamic programming详解-硬币找零问题【python】
10年数据\经营分析经验，现任大厂数据分析负责人
04-16 1566
硬币找零问题是一个经典的动态规划问题，在这个问题中我们详细介绍状态转移方程与推导，以及案例与代码
动态规划（Dynamic Programming）
thdwx的博客
10-28 2316
我们清楚的知道使用分治算法来求解决斐波那契数列的效率惊人的低，其中的原因是，斐波那契数列分解成的两个子问题并不是独立的，它们之间有着非常多的交集，而在递归中，这些交集会被计算成百上千次，从而降低了算法的效率（这也是为什么分治算法要求子问题尽可能的不要相交）。如果观察斐波那契数列的通项公式，我们会发现数列的第n项只与它之前的两项有关，那么知道这两项也就得到了，这种从子问题出发，逐步得到原问题解的思想就是动态规划。
动态规划-Dynamic Programming
qq_36448587的博客
11-17 355
算法-动态规划 Dynamic Programming--从菜鸟到老鸟_有图有真相-CSDN博客_动态规划https://hanking.blog.csdn.net/article/details/75193592?spm=1001.2101.3001.6650.2&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7Edefault-2.no_search_link&depth_1-utm_sour
动态规划问题（Dynamic Programming）
weixin_43057295的博客
06-30 468
动态规划（dynamic programming）是运筹学的一个分支，是求解决策过程（decision process）最优化的数学方法。20 世纪 50 年代初 R. E. Bellman 等人在研究多阶段决策过 程(multistep decision process)的优化问题时，提出了著名的最优性原理（principle of optimality），把多阶段过程转化为一系列单阶段问题，逐个求解，创立了解决这类过程 优化问题的新方法—动态规划。解决：例如最优路线问题，生产计划问题 例子详见阶段(st
什么是动态规划（Dynamic Programming）？动态规划的意义是什么？ - 知乎1
08-03
引入这两个概念之后，我们如何判断一个问题能否使用DP解决呢？能将大问题拆成几个小问题，且满足无后效性、最优子结构性质。3. DP的典型应用：DAG最短路问题很简
动态规划（Dynamic programming）详细解读
10-25
动态规划是一种解决问题的有效方法，尤其在计算机科学和数学领域中广泛应用。它主要通过将复杂问题分解为更小的子问题来解决，然后存储这些子问题的解决方案，避免重复计算，从而提高效率。动态规划的核心思想是“最...
java实现动态规划（Dynamic Programming）
06-14
示例代码展示了如何使用动态规划来计算斐波那契数列的第 n 项。 在代码中，我们定义了一个 fibonacci 方法，它接受一个整数 n 作为输入，并返回斐波那契数列的第 n 项。我们创建了一个大小为 n+1 的数组 dp 来保存...
C++ 多态
最新发布
wxk2227814847的博客
07-10 493
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 393
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C++初探究（2）
Frenemy__的博客
07-09 1255
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 933
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 601
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
动态规划算法(dynamic programming algorithm)
09-20
动态规划算法是一种解决问题的算法思想，它通常用于求解有重叠子问题和最优子结构的问题。通过将问题拆解为一个个相互重叠的子问题，并利用已经求解过的子问题的解来求解更大的问题，从而达到提高效率的目的。 动态...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值